@pioneer_zmc/dsh-workbench 0.2.1

package/dist/check-room.js

@@ -0,0 +1,980 @@
+// 构建产物：由 scripts/build.mjs 从 src/ 生成，请勿手改。
+
+
+// src/cli/check-room.ts
+import path2 from "node:path";
+import { readFile as readFile2, realpath } from "node:fs/promises";
+import { fileURLToPath, pathToFileURL } from "node:url";
+
+// src/core/errors.ts
+var CoreError = class extends Error {
+  code;
+  httpStatus;
+  // 字段在构造函数体内赋值（不用 TS 参数属性）：core 全部保持"可擦除语法"，
+  // 纯 Node 剥类型模式即可加载，scripts/smoke.mjs 不依赖 tsx。
+  constructor(code, message, httpStatus = 500) {
+    super(message);
+    this.code = code;
+    this.httpStatus = httpStatus;
+    this.name = "CoreError";
+  }
+};
+
+// src/core/git.ts
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+import { readFile, stat } from "node:fs/promises";
+import { realpathSync } from "node:fs";
+import path from "node:path";
+var execFileAsync = promisify(execFile);
+var GIT_TIMEOUT_MS = 1e4;
+var MAX_FILE_BYTES = 2 * 1024 * 1024;
+var EXEC_MAX_BUFFER = MAX_FILE_BYTES * 2;
+async function runGit(repoRoot, args) {
+  let caught;
+  try {
+    const { stdout } = await execFileAsync("git", ["-C", repoRoot, ...args], {
+      timeout: GIT_TIMEOUT_MS,
+      maxBuffer: EXEC_MAX_BUFFER,
+      encoding: "utf8",
+      windowsHide: true
+    });
+    return stdout;
+  } catch (error) {
+    caught = error;
+  }
+  const err = caught;
+  if (err.code === "ENOENT") {
+    throw new CoreError("git-unavailable", "\u65E0\u6CD5\u542F\u52A8 git\uFF1A\u672A\u627E\u5230\u53EF\u6267\u884C\u6587\u4EF6\uFF08\u8BF7\u786E\u8BA4\u5DF2\u5B89\u88C5 git \u4E14\u5728 PATH \u4E2D\uFF09", 500);
+  }
+  if (err.killed || err.signal === "SIGTERM") {
+    throw new CoreError("git-timeout", `git ${args[0]} \u8D85\u8FC7 ${GIT_TIMEOUT_MS / 1e3} \u79D2\u672A\u8FD4\u56DE\uFF0C\u5DF2\u4E2D\u6B62`, 504);
+  }
+  const rawText = String(err.stderr || err.message || "");
+  if (/not a git repository/i.test(rawText)) {
+    throw new CoreError(
+      "not-a-git-repo",
+      `\u8FD9\u4E2A\u76EE\u5F55\u4E0D\u662F\u53EF\u7528\u7684 Git \u4ED3\u5E93\uFF1A${repoRoot}\uFF08\u5386\u53F2\u7248\u672C\u4E0E\u5FEB\u7167\u4FE1\u606F\u5B58\u653E\u5728 Git \u91CC\uFF0C\u9700\u8981\u662F Git \u4ED3\u5E93\u624D\u80FD\u7BA1\u7406\uFF09`,
+      422
+    );
+  }
+  const firstLine = rawText.split("\n")[0].trim();
+  throw new CoreError("git-failed", `git ${args[0]} \u5931\u8D25\uFF1A${firstLine || "\u672A\u77E5\u9519\u8BEF"}`);
+}
+function isHex40(value) {
+  return typeof value === "string" && /^[0-9a-f]{40}$/.test(value);
+}
+async function assertRepoUsable(repoRoot) {
+  let info;
+  try {
+    info = await stat(repoRoot);
+  } catch (error) {
+    const code = error?.code;
+    if (code === "ENOENT" || code === "ENOTDIR") {
+      throw new CoreError("repo-unavailable", `\u76EE\u5F55\u4E0D\u5B58\u5728\u6216\u5DF2\u88AB\u79FB\u52A8\uFF1A${repoRoot}`, 404);
+    }
+    throw new CoreError("repo-unavailable", `\u76EE\u5F55\u65E0\u6CD5\u8BFB\u53D6\uFF08${code ?? String(error)}\uFF09\uFF1A${repoRoot}`, 403);
+  }
+  if (!info.isDirectory()) {
+    throw new CoreError("repo-unavailable", `\u8DEF\u5F84\u4E0D\u662F\u4E00\u4E2A\u76EE\u5F55\uFF1A${repoRoot}`, 404);
+  }
+}
+function sameRealPath(a, b) {
+  const norm = (p) => {
+    let resolved;
+    try {
+      resolved = realpathSync(p);
+    } catch {
+      resolved = p;
+    }
+    const unified = path.resolve(resolved);
+    return process.platform === "win32" ? unified.toLowerCase() : unified;
+  };
+  return norm(a) === norm(b);
+}
+async function assertRepoTopLevel(repoRoot) {
+  const output = (await runGit(repoRoot, ["rev-parse", "--show-toplevel"])).trim();
+  if (!output) {
+    throw new CoreError("not-a-git-repo", `\u65E0\u6CD5\u786E\u5B9A ${repoRoot} \u7684 Git \u4ED3\u5E93\u9876\u5C42`, 422);
+  }
+  if (!sameRealPath(output, repoRoot)) {
+    throw new CoreError(
+      "repo-not-top-level",
+      `\u8FD9\u4E2A\u76EE\u5F55\u4E0D\u662F Git \u4ED3\u5E93\u7684\u9876\u5C42\uFF1A${repoRoot} \u5C5E\u4E8E\u5916\u5C42\u4ED3\u5E93 ${output}\u3002\u5386\u53F2\u7248\u672C\u4F1A\u4E0E\u5916\u5C42\u4ED3\u5E93\u6DF7\u5728\u4E00\u8D77\uFF0C\u7BA1\u7406\u9875\u4E0D\u4F1A\u81EA\u52A8\u6539\u7ED1\uFF1B\u8BF7\u628A\u4ED3\u5E93\u9876\u5C42\uFF08${output}\uFF09\u767B\u8BB0\u4E3A\u5DE5\u4F5C\u533A\u3002`,
+      422
+    );
+  }
+}
+async function gitShowFileOptional(repoRoot, commit, relPath) {
+  if (!isHex40(commit)) {
+    throw new CoreError("bad-request", `\u5185\u90E8\u9519\u8BEF\uFF1AgitShowFileOptional \u53EA\u63A5\u53D7 40 \u4F4D\u63D0\u4EA4\u53F7\uFF0C\u6536\u5230 ${commit}`, 400);
+  }
+  const spec = `${commit}:${relPath}`;
+  const entry = (await runGit(repoRoot, ["ls-tree", commit, "--", relPath])).trim();
+  if (entry === "") return null;
+  const objectType = entry.split("	")[0].split(" ")[1];
+  if (objectType !== "blob") return null;
+  const sizeText = await runGit(repoRoot, ["cat-file", "-s", spec]);
+  const size = Number(sizeText.trim());
+  if (!Number.isFinite(size) || size < 0) {
+    throw new CoreError("git-failed", `\u65E0\u6CD5\u786E\u5B9A ${relPath} \u5728\u63D0\u4EA4 ${commit.slice(0, 8)} \u4E0A\u7684\u5927\u5C0F`);
+  }
+  if (size > MAX_FILE_BYTES) {
+    throw new CoreError(
+      "file-too-large",
+      `\u6587\u4EF6 ${relPath} \u5728\u63D0\u4EA4 ${commit.slice(0, 8)} \u4E0A\u4E3A ${size} \u5B57\u8282\uFF0C\u8D85\u8FC7\u8BFB\u53D6\u4E0A\u9650 ${MAX_FILE_BYTES} \u5B57\u8282`,
+      413
+    );
+  }
+  return runGit(repoRoot, ["show", spec]);
+}
+function statConfirmedAbsent(error) {
+  const code = error?.code;
+  return code === "ENOENT" || code === "ENOTDIR";
+}
+function fsFailed(relPath, error) {
+  const code = error?.code;
+  return new CoreError("fs-failed", `\u8BBF\u95EE ${relPath} \u5931\u8D25\uFF08${code ?? String(error)}\uFF09`, 500);
+}
+async function worktreeDirExists(repoRoot, relPath) {
+  const normalized = relPath.split("/").filter((part) => part !== "" && part !== ".");
+  if (normalized.some((part) => part === "..") || path.isAbsolute(relPath)) {
+    throw new CoreError("bad-request", `\u975E\u6CD5\u8DEF\u5F84\uFF1A${relPath}`, 400);
+  }
+  const full = path.resolve(repoRoot, ...normalized);
+  try {
+    return (await stat(full)).isDirectory();
+  } catch (error) {
+    if (statConfirmedAbsent(error)) return false;
+    throw fsFailed(relPath, error);
+  }
+}
+async function worktreeFileExists(repoRoot, relPath) {
+  const normalized = relPath.split("/").filter((part) => part !== "" && part !== ".");
+  if (normalized.some((part) => part === "..") || path.isAbsolute(relPath)) {
+    throw new CoreError("bad-request", `\u975E\u6CD5\u8DEF\u5F84\uFF1A${relPath}`, 400);
+  }
+  const full = path.resolve(repoRoot, ...normalized);
+  try {
+    return (await stat(full)).isFile();
+  } catch (error) {
+    if (statConfirmedAbsent(error)) return false;
+    throw fsFailed(relPath, error);
+  }
+}
+async function readWorktreeFileOptional(repoRoot, relPath) {
+  const normalized = relPath.split("/").filter((part) => part !== "" && part !== ".");
+  if (normalized.some((part) => part === "..") || path.isAbsolute(relPath)) {
+    throw new CoreError("bad-request", `\u975E\u6CD5\u8DEF\u5F84\uFF1A${relPath}`, 400);
+  }
+  const full = path.resolve(repoRoot, ...normalized);
+  const root = path.resolve(repoRoot);
+  if (full !== root && !full.startsWith(root + path.sep)) {
+    throw new CoreError("bad-request", `\u8DEF\u5F84\u8D8A\u51FA\u4ED3\u5E93\u6839\uFF1A${relPath}`, 400);
+  }
+  let size;
+  try {
+    size = (await stat(full)).size;
+  } catch (error) {
+    if (statConfirmedAbsent(error)) return null;
+    throw fsFailed(relPath, error);
+  }
+  if (size > MAX_FILE_BYTES) {
+    throw new CoreError(
+      "file-too-large",
+      `\u6587\u4EF6 ${relPath} \u4E3A ${size} \u5B57\u8282\uFF0C\u8D85\u8FC7\u8BFB\u53D6\u4E0A\u9650 ${MAX_FILE_BYTES} \u5B57\u8282`,
+      413
+    );
+  }
+  return readFile(full, "utf8");
+}
+
+// src/core/inventory.ts
+import { readdir as readdir2 } from "node:fs/promises";
+
+// src/core/types.ts
+var CONVENTION_ROOT = "docs/specdev";
+var SCHEMA = {
+  project: "specdev/project/1",
+  business: "specdev/business/1",
+  chart: "specdev/chart/1",
+  evidence: "specdev/evidence/1",
+  snapshot: "specdev/snapshot/1"
+};
+var BUILDING_BLUEPRINT_REL = `${CONVENTION_ROOT}/building.json`;
+
+// src/core/snapshots.ts
+var STAGES = ["design", "implemented"];
+function parseTagName(tag) {
+  const parts = tag.split("/");
+  if (parts.length < 3 || parts[0] !== "specdev" || !parts[1] || parts.some((p) => p === "")) return null;
+  return { chart: parts[1], version: parts.slice(2).join("/") };
+}
+async function listSpecdevTags(repoRoot) {
+  const format = "%(refname:short)%09%(objecttype)%09%(*objectname)%09%(*objecttype)%09%(creatordate:iso8601-strict)%09%(contents)%00";
+  const out = await runGit(repoRoot, ["for-each-ref", `refs/tags/${"specdev"}/`, `--format=${format}`]);
+  const records = [];
+  for (const raw of out.split("\0")) {
+    const chunk = raw.replace(/^[\r\n]+/, "").replace(/[\r\n]+$/, "");
+    if (!chunk) continue;
+    const head = chunk.indexOf("	");
+    if (head < 0) continue;
+    const rest = chunk.slice(head + 1);
+    const fields = rest.split("	");
+    records.push({
+      tag: chunk.slice(0, head),
+      objecttype: fields[0],
+      derefObject: fields[1],
+      derefType: fields[2],
+      createdDate: fields[3],
+      message: fields.slice(4).join("	")
+    });
+  }
+  return records;
+}
+function validateRecord(record) {
+  const parsed = parseTagName(record.tag);
+  if (!parsed) return { invalid: "\u6807\u7B7E\u540D\u4E0D\u7B26\u5408 specdev/<\u56FE\u7F16\u53F7>/<\u7248\u672C> \u7ED3\u6784" };
+  if (record.objecttype !== "tag") return { invalid: "\u4E0D\u662F\u9644\u6CE8\u6807\u7B7E\uFF08\u8F7B\u91CF\u6807\u7B7E\u4E0D\u767B\u8BB0\u5FEB\u7167\uFF09" };
+  if (!/^[0-9a-f]{40}$/.test(record.derefObject)) return { invalid: "\u5265\u58F3\u540E\u6CA1\u6709\u6307\u5411\u6709\u6548\u5BF9\u8C61" };
+  if (record.derefType !== "commit") {
+    return { invalid: `\u6807\u7B7E\u5265\u58F3\u540E\u6307\u5411\u7684\u4E0D\u662F\u63D0\u4EA4\uFF08${record.derefType || "\u65E0\u5BF9\u8C61"}\uFF09\uFF0C\u5FEB\u7167\u5FC5\u987B\u843D\u5728\u5177\u4F53\u63D0\u4EA4\u4E0A` };
+  }
+  let meta;
+  try {
+    meta = JSON.parse(record.message);
+  } catch {
+    return { invalid: "\u6807\u7B7E message \u4E0D\u662F\u5408\u6CD5 JSON" };
+  }
+  if (typeof meta !== "object" || meta === null || Array.isArray(meta)) return { invalid: "\u6807\u7B7E message \u4E0D\u662F JSON \u5BF9\u8C61" };
+  const m = meta;
+  if (m.schema !== SCHEMA.snapshot) return { invalid: `message.schema \u4E0D\u662F ${SCHEMA.snapshot}` };
+  if (typeof m.chart !== "string" || !m.chart) return { invalid: "message.chart \u7F3A\u5931\u6216\u4E0D\u662F\u5B57\u7B26\u4E32" };
+  if (typeof m.name !== "string" || !m.name.trim()) return { invalid: "message.name \u7F3A\u5931\u6216\u4E3A\u7A7A" };
+  if (!STAGES.includes(m.stage)) return { invalid: `message.stage \u5FC5\u987B\u662F ${STAGES.join(" / ")}` };
+  if (typeof m.dir !== "string" || !m.dir.startsWith(CONVENTION_ROOT + "/")) {
+    return { invalid: `message.dir \u5FC5\u987B\u4EE5 ${CONVENTION_ROOT}/ \u5F00\u5934` };
+  }
+  if (m.chart !== parsed.chart) return { invalid: `message.chart\uFF08${m.chart}\uFF09\u4E0E\u6807\u7B7E\u540D\u91CC\u7684\u56FE\u7F16\u53F7\uFF08${parsed.chart}\uFF09\u4E0D\u4E00\u81F4` };
+  if (m.savedAt !== void 0 && typeof m.savedAt !== "string") return { invalid: "message.savedAt \u4E0D\u662F\u5B57\u7B26\u4E32" };
+  if (m.note !== void 0 && typeof m.note !== "string") return { invalid: "message.note \u4E0D\u662F\u5B57\u7B26\u4E32" };
+  return {
+    meta: {
+      schema: SCHEMA.snapshot,
+      chart: m.chart,
+      name: m.name,
+      stage: m.stage,
+      note: m.note,
+      dir: m.dir,
+      savedAt: m.savedAt
+    },
+    commit: record.derefObject
+  };
+}
+function snapshotsForChart(records, chartId) {
+  const snapshots = [];
+  let invalidCount = 0;
+  const invalidSamples = [];
+  for (const record of records) {
+    const parsed = parseTagName(record.tag);
+    if (!parsed || parsed.chart !== chartId) continue;
+    const result = validateRecord(record);
+    if ("invalid" in result) {
+      invalidCount += 1;
+      if (invalidSamples.length < 5) invalidSamples.push(record.tag);
+      continue;
+    }
+    snapshots.push({
+      tag: record.tag,
+      version: parsed.version,
+      chart: chartId,
+      commit: result.commit,
+      createdDate: record.createdDate,
+      meta: result.meta
+    });
+  }
+  snapshots.sort((a, b) => {
+    const keyA = a.meta.savedAt ?? a.createdDate;
+    const keyB = b.meta.savedAt ?? b.createdDate;
+    if (keyA !== keyB) return keyA < keyB ? 1 : -1;
+    return a.tag < b.tag ? 1 : -1;
+  });
+  return { snapshots, invalidCount, invalidSamples };
+}
+function findSnapshot(records, tag) {
+  const record = records.find((item) => item.tag === tag);
+  if (!record) {
+    throw new CoreError("not-found", `\u6807\u7B7E ${tag} \u4E0D\u5B58\u5728`, 404);
+  }
+  const result = validateRecord(record);
+  if ("invalid" in result) {
+    throw new CoreError("not-found", `\u6807\u7B7E ${tag} \u4E0D\u7B26\u5408\u5FEB\u7167\u7EA6\u5B9A\uFF08${result.invalid}\uFF09\uFF0C\u5DF2\u88AB\u5FFD\u7565`, 404);
+  }
+  const parsed = parseTagName(tag);
+  return {
+    tag,
+    version: parsed.version,
+    chart: parsed.chart,
+    commit: result.commit,
+    createdDate: record.createdDate,
+    meta: result.meta
+  };
+}
+
+// src/core/chart.ts
+import { readdir } from "node:fs/promises";
+
+// src/core/descriptor.ts
+async function readDescriptor(repoRoot, relPath) {
+  const text = await readWorktreeFileOptional(repoRoot, relPath);
+  if (text === null) return { data: null, error: `\u7F3A\u5C11\u8BF4\u660E\u6587\u4EF6 ${relPath}` };
+  try {
+    return { data: JSON.parse(text) };
+  } catch (error) {
+    return { data: null, error: `${relPath} \u4E0D\u662F\u5408\u6CD5 JSON\uFF1A${error.message}` };
+  }
+}
+function isPlainObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function requireStringFields(record, fields) {
+  for (const field of fields) {
+    const value = record[field];
+    if (typeof value !== "string" || !value.trim()) return `${field} \u7F3A\u5931\u6216\u4E0D\u662F\u975E\u7A7A\u5B57\u7B26\u4E32`;
+  }
+  return null;
+}
+
+// src/core/chart-files.ts
+var CHART_FILE_NAMES = ["workflow.json", "details.md", "evidence.json"];
+var FILE_KEY = {
+  "workflow.json": "workflow",
+  "details.md": "details",
+  "evidence.json": "evidence"
+};
+
+// src/core/fingerprint.ts
+import { createHash } from "node:crypto";
+function normalizeEol(text) {
+  return text.replace(/\r\n/g, "\n");
+}
+function fingerprintOf(files) {
+  const json = JSON.stringify(
+    CHART_FILE_NAMES.map((name) => {
+      const text = files[FILE_KEY[name]];
+      return text === null ? null : normalizeEol(text);
+    })
+  );
+  return createHash("sha256").update(json, "utf8").digest("hex");
+}
+
+// src/core/chart.ts
+async function chartIdOwners(repoRoot, chartId) {
+  const entries = await readdir(`${repoRoot}/${CONVENTION_ROOT}`, { withFileTypes: true });
+  const owners = [];
+  for (const entry of entries) {
+    if (!entry.isDirectory()) continue;
+    if (await worktreeDirExists(repoRoot, `${CONVENTION_ROOT}/${entry.name}/${chartId}`)) owners.push(entry.name);
+  }
+  return owners;
+}
+async function locateChartDir(repoRoot, businessId, chartId) {
+  const businessDir = `${CONVENTION_ROOT}/${businessId}`;
+  const chartDir = `${businessDir}/${chartId}`;
+  if (!await worktreeDirExists(repoRoot, businessDir)) {
+    throw new CoreError("not-found", `\u4E1A\u52A1 ${businessId} \u4E0D\u5B58\u5728\uFF08\u7EA6\u5B9A\u76EE\u5F55 ${businessDir} \u4E0D\u5B58\u5728\uFF09`, 404);
+  }
+  if (!await worktreeDirExists(repoRoot, chartDir)) {
+    throw new CoreError("not-found", `\u56FE ${chartId} \u4E0D\u5B58\u5728\uFF08\u7EA6\u5B9A\u76EE\u5F55 ${chartDir} \u4E0D\u5B58\u5728\uFF09`, 404);
+  }
+  const owners = await chartIdOwners(repoRoot, chartId);
+  if (owners.length > 1) {
+    throw new CoreError(
+      "duplicate-chart-id",
+      `\u56FE\u7F16\u53F7 ${chartId} \u540C\u65F6\u5B58\u5728\u4E8E\u4E1A\u52A1\uFF08${owners.join("\u3001")}\uFF09\u4E0B\uFF1A\u5386\u53F2\u5FEB\u7167\u6309\u56FE\u7F16\u53F7\u5F52\u7EC4\uFF0C\u65E0\u6CD5\u533A\u5206\u5F52\u5C5E\u3002\u8BF7\u628A\u5176\u4E2D\u4E00\u4E2A\u56FE\u76EE\u5F55\u6539\u6210\u4E0D\u540C\u7684\u7F16\u53F7\u3002`,
+      409
+    );
+  }
+  return chartDir;
+}
+function normalizeOrNull(text) {
+  return text === null ? null : normalizeEol(text);
+}
+async function compareCurrentWithLatest(repoRoot, chartDir, latest) {
+  for (const name of CHART_FILE_NAMES) {
+    const worktree = await readWorktreeFileOptional(repoRoot, `${chartDir}/${name}`);
+    const snapshot = await gitShowFileOptional(repoRoot, latest.commit, `${latest.meta.dir}/${name}`);
+    if (normalizeOrNull(worktree) !== normalizeOrNull(snapshot)) return "changed";
+  }
+  return "identical";
+}
+var FILE_KEYS = { "workflow.json": "workflow", "details.md": "details", "evidence.json": "evidence" };
+async function readWorktreeFiles(repoRoot, chartDir) {
+  const files = { workflow: null, details: null, evidence: null };
+  const errors = {};
+  for (const name of CHART_FILE_NAMES) {
+    const key = FILE_KEYS[name];
+    try {
+      files[key] = await readWorktreeFileOptional(repoRoot, `${chartDir}/${name}`);
+    } catch (error) {
+      errors[key] = error instanceof Error ? error.message : String(error);
+    }
+  }
+  return { files, errors };
+}
+async function readSnapshotFiles(repoRoot, snapshot) {
+  const dir = snapshot.meta.dir;
+  const files = { workflow: null, details: null, evidence: null };
+  const errors = {};
+  for (const name of CHART_FILE_NAMES) {
+    const key = FILE_KEYS[name];
+    try {
+      files[key] = await gitShowFileOptional(repoRoot, snapshot.commit, `${dir}/${name}`);
+    } catch (error) {
+      errors[key] = error instanceof Error ? error.message : String(error);
+    }
+  }
+  return { files, errors };
+}
+async function readChartPage(repoRoot, businessId, chartId, v) {
+  const businessDir = `${CONVENTION_ROOT}/${businessId}`;
+  const chartDir = await locateChartDir(repoRoot, businessId, chartId);
+  const business = await readDescriptor(repoRoot, `${businessDir}/business.json`);
+  const chart = await readDescriptor(repoRoot, `${chartDir}/chart.json`);
+  const chartName = chart.data && isPlainObject(chart.data) && typeof chart.data.name === "string" ? chart.data.name : chartId;
+  const chartSummaryOk = !!(chart.data && isPlainObject(chart.data) && chart.data.schema === SCHEMA.chart && !requireStringFields(chart.data, ["id", "name"]) && chart.data.id === chartId);
+  const tagRecords = await listSpecdevTags(repoRoot);
+  const snapshots = snapshotsForChart(tagRecords, chartId);
+  const latest = snapshots.snapshots[0];
+  let currentStatus;
+  let compareError;
+  if (!latest) {
+    currentStatus = "no-snapshot";
+  } else {
+    try {
+      currentStatus = await compareCurrentWithLatest(repoRoot, chartDir, latest);
+    } catch (error) {
+      currentStatus = "compare-failed";
+      compareError = error instanceof Error ? error.message : String(error);
+    }
+  }
+  let version;
+  let currentFingerprint = null;
+  if (v === "current") {
+    const { files, errors } = await readWorktreeFiles(repoRoot, chartDir);
+    currentFingerprint = errors.workflow || errors.details || errors.evidence ? null : fingerprintOf(files);
+    version = {
+      kind: "current",
+      files,
+      workflowError: errors.workflow ?? (files.workflow === null ? `\u5F53\u524D\u5DE5\u4F5C\u533A\u7F3A\u5C11 workflow.json\uFF08${chartDir}/workflow.json\uFF09\uFF0C\u8BE5\u56FE\u4E0D\u53EF\u8BFB` : void 0),
+      workflowErrorKind: errors.workflow ? "unreadable" : files.workflow === null ? "missing" : void 0,
+      detailsError: errors.details,
+      evidenceError: errors.evidence
+    };
+  } else {
+    const parsed = parseTagName(v);
+    if (!parsed || parsed.chart !== chartId) {
+      throw new CoreError("bad-request", `\u7248\u672C\u53C2\u6570\u5FC5\u987B\u662F current \u6216\u672C\u56FE\uFF08${chartId}\uFF09\u7684\u6807\u7B7E\u540D\uFF0C\u6536\u5230\uFF1A${v}`, 400);
+    }
+    const snapshot = findSnapshot(tagRecords, v);
+    const { files, errors } = await readSnapshotFiles(repoRoot, snapshot);
+    version = {
+      kind: "snapshot",
+      tag: snapshot.tag,
+      commit: snapshot.commit,
+      label: snapshot.meta.name,
+      stage: snapshot.meta.stage,
+      note: snapshot.meta.note,
+      savedAt: snapshot.meta.savedAt,
+      files,
+      workflowError: errors.workflow ?? (files.workflow === null ? `\u5FEB\u7167 ${snapshot.tag} \u91CC\u7F3A\u5C11 workflow.json\uFF08\u767B\u8BB0\u76EE\u5F55 ${snapshot.meta.dir}\uFF09\uFF0C\u8BE5\u7248\u672C\u4E0D\u53EF\u8BFB` : void 0),
+      workflowErrorKind: errors.workflow ? "unreadable" : files.workflow === null ? "missing" : void 0,
+      detailsError: errors.details,
+      evidenceError: errors.evidence
+    };
+  }
+  return {
+    business: {
+      id: businessId,
+      name: business.data && isPlainObject(business.data) && typeof business.data.name === "string" ? business.data.name : businessId
+    },
+    chart: { id: chartId, name: chartName, summary: chartSummaryOk && typeof chart.data?.summary === "string" ? chart.data.summary : void 0 },
+    snapshots,
+    currentStatus,
+    compareError,
+    version,
+    currentFingerprint
+  };
+}
+
+// src/core/inventory.ts
+async function readProjectInfo(repoRoot) {
+  const relPath = `${CONVENTION_ROOT}/project.json`;
+  const text = await readWorktreeFileOptional(repoRoot, relPath);
+  if (text === null) {
+    throw new CoreError(
+      "no-convention-root",
+      `\u8FD9\u91CC\u8FD8\u6CA1\u6709\u6D41\u7A0B\u56FE\u8D44\u6599\uFF1A\u672A\u627E\u5230 ${relPath}\u3002\u4E0D\u4F1A\u81EA\u52A8\u521B\u5EFA\u6216\u6539\u52A8\u8FD9\u4E2A\u76EE\u5F55\u91CC\u7684\u4EFB\u4F55\u6587\u4EF6\u3002`,
+      404
+    );
+  }
+  let data;
+  try {
+    data = JSON.parse(text);
+  } catch (error) {
+    throw new CoreError("bad-inventory", `${relPath} \u4E0D\u662F\u5408\u6CD5 JSON\uFF1A${error.message}`, 500);
+  }
+  if (!isPlainObject(data) || data.schema !== SCHEMA.project) {
+    throw new CoreError("bad-inventory", `${relPath} \u7684 schema \u5FC5\u987B\u662F ${SCHEMA.project}`, 500);
+  }
+  const fieldError = requireStringFields(data, ["name"]);
+  if (fieldError) throw new CoreError("bad-inventory", `${relPath}\uFF1A${fieldError}`, 500);
+  return data;
+}
+async function readInventory(repoRoot) {
+  const project = await readProjectInfo(repoRoot);
+  const tagRecords = await listSpecdevTags(repoRoot);
+  const businessEntries = await readdir2(`${repoRoot}/${CONVENTION_ROOT}`, { withFileTypes: true });
+  const businesses = [];
+  for (const entry of businessEntries) {
+    if (!entry.isDirectory()) continue;
+    const businessId = entry.name;
+    const businessDir = `${CONVENTION_ROOT}/${businessId}`;
+    const summary = { id: businessId, name: businessId, docs: [], charts: [] };
+    const { data, error } = await readDescriptor(repoRoot, `${businessDir}/business.json`);
+    if (!data) {
+      summary.descriptorError = error ?? "business.json \u7F3A\u5931";
+      businesses.push(summary);
+      continue;
+    }
+    if (!isPlainObject(data) || data.schema !== SCHEMA.business) {
+      summary.descriptorError = `${businessDir}/business.json \u7684 schema \u5FC5\u987B\u662F ${SCHEMA.business}`;
+      businesses.push(summary);
+      continue;
+    }
+    const fieldError = requireStringFields(data, ["id", "name"]);
+    if (fieldError) {
+      summary.descriptorError = `${businessDir}/business.json\uFF1A${fieldError}`;
+      businesses.push(summary);
+      continue;
+    }
+    if (data.id !== businessId) {
+      summary.descriptorError = `business.json \u7684 id\uFF08${data.id}\uFF09\u4E0E\u76EE\u5F55\u540D\uFF08${businessId}\uFF09\u4E0D\u4E00\u81F4`;
+      businesses.push(summary);
+      continue;
+    }
+    summary.name = data.name;
+    summary.intro = typeof data.intro === "string" ? data.intro : void 0;
+    if (Array.isArray(data.docs)) {
+      summary.docs = data.docs.filter((item) => typeof item === "string" && item !== "");
+    }
+    summary.charts = await readChartSummaries(repoRoot, businessDir, tagRecords);
+    businesses.push(summary);
+  }
+  businesses.sort((a, b) => a.name < b.name ? -1 : a.name > b.name ? 1 : 0);
+  const ownersByChartId = /* @__PURE__ */ new Map();
+  for (const business of businesses) {
+    for (const chart of business.charts) {
+      ownersByChartId.set(chart.id, [...ownersByChartId.get(chart.id) ?? [], business.id]);
+    }
+  }
+  for (const business of businesses) {
+    for (const chart of business.charts) {
+      const owners = ownersByChartId.get(chart.id) ?? [];
+      if (owners.length > 1) {
+        chart.idConflict = `\u56FE\u7F16\u53F7 ${chart.id} \u5728\u4E1A\u52A1\uFF08${owners.join("\u3001")}\uFF09\u4E2D\u91CD\u590D\uFF1A\u5386\u53F2\u5FEB\u7167\u6309\u56FE\u7F16\u53F7\u5F52\u7EC4\uFF0C\u65E0\u6CD5\u533A\u5206\u5F52\u5C5E\uFF0C\u8BE5\u56FE\u7684\u9605\u8BFB\u5DF2\u505C\u7528\uFF08\u76F4\u8FBE\u9605\u8BFB\u9875\u4F1A\u660E\u786E\u62A5\u9519\uFF09`;
+      }
+    }
+  }
+  return { project, businesses };
+}
+async function readChartSummaries(repoRoot, businessDir, tagRecords) {
+  const chartEntries = await readdir2(`${repoRoot}/${businessDir}`, { withFileTypes: true });
+  const charts = [];
+  for (const entry of chartEntries) {
+    if (!entry.isDirectory()) continue;
+    const chartId = entry.name;
+    const chartDir = `${businessDir}/${chartId}`;
+    const snapshots = snapshotsForChart(tagRecords, chartId);
+    const summary = {
+      id: chartId,
+      name: chartId,
+      hasWorkflow: await worktreeFileExists(repoRoot, `${chartDir}/workflow.json`),
+      snapshotCount: snapshots.snapshots.length,
+      invalidTagCount: snapshots.invalidCount,
+      currentStatus: "no-snapshot"
+    };
+    const { data, error } = await readDescriptor(repoRoot, `${chartDir}/chart.json`);
+    if (!data) {
+      summary.descriptorError = error ?? "chart.json \u7F3A\u5931";
+      charts.push(summary);
+      continue;
+    }
+    if (!isPlainObject(data) || data.schema !== SCHEMA.chart) {
+      summary.descriptorError = `${chartDir}/chart.json \u7684 schema \u5FC5\u987B\u662F ${SCHEMA.chart}`;
+      charts.push(summary);
+      continue;
+    }
+    const fieldError = requireStringFields(data, ["id", "name"]);
+    if (fieldError) {
+      summary.descriptorError = `${chartDir}/chart.json\uFF1A${fieldError}`;
+      charts.push(summary);
+      continue;
+    }
+    if (data.id !== chartId) {
+      summary.descriptorError = `chart.json \u7684 id\uFF08${data.id}\uFF09\u4E0E\u76EE\u5F55\u540D\uFF08${chartId}\uFF09\u4E0D\u4E00\u81F4`;
+      charts.push(summary);
+      continue;
+    }
+    summary.name = data.name;
+    summary.summary = typeof data.summary === "string" ? data.summary : void 0;
+    const latest = snapshots.snapshots[0];
+    if (latest) {
+      try {
+        summary.currentStatus = await compareCurrentWithLatest(repoRoot, chartDir, latest);
+      } catch (error2) {
+        summary.currentStatus = "compare-failed";
+        summary.compareError = error2 instanceof Error ? error2.message : String(error2);
+      }
+      summary.latestSnapshot = {
+        tag: latest.tag,
+        name: latest.meta.name,
+        stage: latest.meta.stage,
+        savedAt: latest.meta.savedAt,
+        createdDate: latest.createdDate
+      };
+    }
+    charts.push(summary);
+  }
+  charts.sort((a, b) => a.name < b.name ? -1 : a.name > b.name ? 1 : 0);
+  return charts;
+}
+
+// src/core/room.ts
+var ROOM_REQUIRED_FIELDS = ["schemaVersion", "roomId", "businessId", "templateRef", "instances"];
+var ROOM_ALLOWED_FIELDS = [...ROOM_REQUIRED_FIELDS, "bindings"];
+var ID_PATTERN = /^[A-Za-z0-9][A-Za-z0-9._-]*$/;
+function roomLayoutRel(businessId) {
+  return `${CONVENTION_ROOT}/${businessId}/room.json`;
+}
+async function readRoomLayout(repoRoot, businessId) {
+  if (!ID_PATTERN.test(businessId)) {
+    throw new CoreError("bad-request", `\u53C2\u6570 business \u4E0D\u5408\u6CD5\uFF1A${businessId}`, 400);
+  }
+  const inventory = await readInventory(repoRoot);
+  const business = inventory.businesses.find((item) => item.id === businessId);
+  if (!business) {
+    throw new CoreError("not-found", `\u4E1A\u52A1 ${businessId} \u4E0D\u5B58\u5728\uFF08\u9879\u76EE\u6E05\u5355\u91CC\u6CA1\u6709\u8FD9\u4E2A\u4E1A\u52A1\uFF09`, 404);
+  }
+  if (business.descriptorError) {
+    throw new CoreError(
+      "bad-business",
+      `\u4E1A\u52A1 ${businessId} \u7684\u8BF4\u660E\u6587\u4EF6\u6709\u95EE\u9898\uFF0C\u4E0D\u80FD\u5F53\u4F5C\u53EF\u7528\u4E1A\u52A1\uFF1A${business.descriptorError}`,
+      422
+    );
+  }
+  const relPath = roomLayoutRel(businessId);
+  const text = await readWorktreeFileOptional(repoRoot, relPath);
+  if (text === null) {
+    throw new CoreError(
+      "no-room-layout",
+      `\u4E1A\u52A1 ${businessId} \u8FD8\u6CA1\u6709\u623F\u95F4\u914D\u7F6E\uFF1A\u672A\u627E\u5230 ${relPath}\u3002\u4E0D\u4F1A\u81EA\u52A8\u751F\u6210\uFF0C\u4E5F\u4E0D\u56DE\u9000\u5230\u6837\u4F8B\u3002`,
+      404
+    );
+  }
+  let layout;
+  try {
+    layout = JSON.parse(text);
+  } catch (error) {
+    throw new CoreError("bad-room-layout", `${relPath} \u4E0D\u662F\u5408\u6CD5 JSON\uFF1A${error.message}`, 422);
+  }
+  if (!isPlainObject(layout)) {
+    throw new CoreError(
+      "bad-room-layout",
+      `${relPath} \u9876\u5C42\u5FC5\u987B\u662F JSON \u5BF9\u8C61\uFF0C\u5B9E\u9645\u662F ${Array.isArray(layout) ? "\u6570\u7EC4" : typeof layout}`,
+      422
+    );
+  }
+  const unknownFields = Object.keys(layout).filter((key) => !ROOM_ALLOWED_FIELDS.includes(key));
+  if (unknownFields.length > 0) {
+    throw new CoreError(
+      "bad-room-layout",
+      `${relPath} \u53EA\u5141\u8BB8\u5B57\u6BB5 ${ROOM_ALLOWED_FIELDS.join("\u3001")}\uFF0C\u591A\u51FA\uFF1A${unknownFields.join("\u3001")}`,
+      422
+    );
+  }
+  const missingFields = ROOM_REQUIRED_FIELDS.filter((field) => !(field in layout));
+  if (missingFields.length > 0) {
+    throw new CoreError("bad-room-layout", `${relPath} \u7F3A\u5FC5\u586B\u5B57\u6BB5\uFF1A${missingFields.join("\u3001")}`, 422);
+  }
+  if (typeof layout.schemaVersion !== "number" || layout.schemaVersion !== 1) {
+    throw new CoreError(
+      "bad-room-layout",
+      `${relPath} \u7684 schemaVersion \u5FC5\u987B\u662F\u6570\u5B57 1\uFF08\u5B9E\u9645\u662F ${JSON.stringify(layout.schemaVersion)}\uFF09`,
+      422
+    );
+  }
+  if (typeof layout.roomId !== "string" || !ID_PATTERN.test(layout.roomId)) {
+    throw new CoreError(
+      "bad-room-layout",
+      `${relPath} \u7684 roomId \u5FC5\u987B\u662F\u7B26\u5408 ID \u89C4\u5219\uFF08\u5B57\u6BCD\u6570\u5B57\u5F00\u5934\uFF0C\u53EF\u542B . _ -\uFF09\u7684\u975E\u7A7A\u5B57\u7B26\u4E32\uFF08\u5B9E\u9645\u662F ${JSON.stringify(layout.roomId)}\uFF09`,
+      422
+    );
+  }
+  if (typeof layout.businessId !== "string" || !ID_PATTERN.test(layout.businessId)) {
+    throw new CoreError(
+      "bad-room-layout",
+      `${relPath} \u7684 businessId \u5FC5\u987B\u662F\u7B26\u5408 ID \u89C4\u5219\u7684\u975E\u7A7A\u5B57\u7B26\u4E32\uFF08\u5B9E\u9645\u662F ${JSON.stringify(layout.businessId)}\uFF09`,
+      422
+    );
+  }
+  if (typeof layout.templateRef !== "string" || !layout.templateRef.trim()) {
+    throw new CoreError(
+      "bad-room-layout",
+      `${relPath} \u7684 templateRef \u5FC5\u987B\u662F\u975E\u7A7A\u5B57\u7B26\u4E32\uFF08\u5B9E\u9645\u662F ${JSON.stringify(layout.templateRef)}\uFF09`,
+      422
+    );
+  }
+  if (!Array.isArray(layout.instances)) {
+    throw new CoreError(
+      "bad-room-layout",
+      `${relPath} \u7684 instances \u5FC5\u987B\u662F\u6570\u7EC4\uFF08\u7A7A\u6570\u7EC4\uFF1D\u7A7A\u623F\u95F4\uFF1B\u5B9E\u9645\u662F ${typeof layout.instances}\uFF09`,
+      422
+    );
+  }
+  if ("bindings" in layout && !Array.isArray(layout.bindings)) {
+    throw new CoreError(
+      "bad-room-layout",
+      `${relPath} \u7684 bindings \u5FC5\u987B\u662F\u6570\u7EC4\uFF08\u7701\u7565\u6216\u7A7A\u6570\u7EC4\uFF1D\u6CA1\u6709\u5BB6\u5177\u8D44\u6599\u7ED1\u5B9A\uFF1B\u5B9E\u9645\u662F ${layout.bindings === null ? "null" : typeof layout.bindings}\uFF09`,
+      422
+    );
+  }
+  if (layout.businessId !== businessId) {
+    throw new CoreError(
+      "room-business-mismatch",
+      `${relPath} \u7684 businessId\uFF08${layout.businessId}\uFF09\u4E0E\u8BF7\u6C42\u7684\u4E1A\u52A1\uFF08${businessId}\uFF09\u4E0D\u4E00\u81F4\uFF1A\u623F\u95F4\u914D\u7F6E\u53EA\u5F52\u5C5E\u5B83\u767B\u8BB0\u7684\u4E1A\u52A1\u3002`,
+      422
+    );
+  }
+  return {
+    // docs 来自该业务清单登记（business.json 的 docs），charts 是本业务图目录的投影
+    // （E9c，既有 inventory 扫描结果：目录内 chart.json/workflow.json 等按既有规则扫描，
+    // 不新开扫描器，也不在 business.json 里加 charts 登记数组）；页面拿一次房间响应即可
+    // 校验文档与图的资料绑定——不从 room.json 接受 docs/charts，也不混入其他业务（E3a/E9c）。
+    business: {
+      id: business.id,
+      name: business.name,
+      intro: business.intro,
+      docs: business.docs,
+      charts: business.charts.map((chart) => ({
+        id: chart.id,
+        name: chart.name,
+        ...chart.summary === void 0 ? {} : { summary: chart.summary },
+        hasWorkflow: chart.hasWorkflow,
+        ...chart.descriptorError === void 0 ? {} : { descriptorError: chart.descriptorError },
+        ...chart.idConflict === void 0 ? {} : { idConflict: chart.idConflict }
+      }))
+    },
+    layout,
+    source: { path: relPath }
+  };
+}
+
+// src/cli/check-room.ts
+var USAGE = "\u7528\u6CD5\uFF1Anode <\u63D2\u4EF6\u5305\u6839>/dist/check-room.js <\u9879\u76EE\u4ED3\u5E93\u6839> <\u4E1A\u52A1ID> [--json]";
+var ID_PATTERN2 = /^[A-Za-z0-9][A-Za-z0-9._-]*$/;
+var PACKAGE_ROOT = fileURLToPath(new URL("../", import.meta.url));
+var isObject = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var reasonOf = (error) => error instanceof Error ? error.message : String(error);
+function initialOutcome() {
+  return { schemaVersion: 1, kind: "failed", ok: false, repoRoot: null, businessId: null, sourcePath: null, diagnostics: [] };
+}
+function withProblems(outcome, kind, diagnostics) {
+  return { ...outcome, kind, ok: false, diagnostics };
+}
+function atStage(diagnostics, stage) {
+  return diagnostics.map((diagnostic) => ({ ...diagnostic, stage }));
+}
+async function runRoomCheck(input, businessId) {
+  let outcome = initialOutcome();
+  let stage = "input";
+  try {
+    if (!input || !ID_PATTERN2.test(businessId)) {
+      throw new CoreError("bad-request", "\u9700\u8981\u975E\u7A7A\u9879\u76EE\u4ED3\u5E93\u6839\u548C\u5408\u6CD5\u4E1A\u52A1 ID\uFF08\u5B57\u6BCD\u6570\u5B57\u5F00\u5934\uFF0C\u53EF\u542B . _ -\uFF09", 400);
+    }
+    outcome = { ...outcome, repoRoot: path2.resolve(input), businessId, sourcePath: roomLayoutRel(businessId) };
+    const repoRoot = outcome.repoRoot;
+    stage = "repo";
+    await assertRepoUsable(repoRoot);
+    await assertRepoTopLevel(repoRoot);
+    stage = "read";
+    const { business, layout } = await readRoomLayout(repoRoot, businessId);
+    stage = "resources";
+    const packageReal = await realpath(PACKAGE_ROOT);
+    const webRoot = path2.join(packageReal, "web");
+    const resourcePath = async (relative) => {
+      try {
+        const absolute = await realpath(path2.join(webRoot, relative));
+        const fromWeb = path2.relative(webRoot, absolute);
+        if (fromWeb === ".." || fromWeb.startsWith(".." + path2.sep) || path2.isAbsolute(fromWeb)) {
+          throw new Error("\u8D44\u6E90\u8DEF\u5F84\u8D8A\u51FA\u8FD0\u884C\u5305\u7684 web \u76EE\u5F55");
+        }
+        return absolute;
+      } catch (error) {
+        throw new CoreError("ROOM_RESOURCE_READ", `\u65E0\u6CD5\u8BFB\u53D6\u8FD0\u884C\u5305\u8D44\u6E90 web/${relative}\uFF1A${reasonOf(error)}`, 500);
+      }
+    };
+    const readJson = async (relative) => {
+      try {
+        return JSON.parse(await readFile2(await resourcePath(relative), "utf8"));
+      } catch (error) {
+        if (error instanceof CoreError) throw error;
+        throw new CoreError("ROOM_RESOURCE_READ", `\u65E0\u6CD5\u89E3\u6790\u8FD0\u884C\u5305\u8D44\u6E90 web/${relative}\uFF1A${reasonOf(error)}`, 500);
+      }
+    };
+    const importResource = async (relative) => {
+      try {
+        const url = pathToFileURL(await resourcePath(relative)).href;
+        return await import(url);
+      } catch (error) {
+        if (error instanceof CoreError) throw error;
+        throw new CoreError("ROOM_RESOURCE_READ", `\u65E0\u6CD5\u5BFC\u5165\u8FD0\u884C\u5305\u6A21\u5757 web/${relative}\uFF1A${reasonOf(error)}`, 500);
+      }
+    };
+    const templates = await readJson("assets/rooms/templates.json");
+    if (!isObject(templates) || templates.schemaVersion !== 1 || !Array.isArray(templates.templates)) {
+      return withProblems(outcome, "failed", [{ stage: "template", code: "TEMPLATE_INPUT", message: "\u8FD0\u884C\u5305 templates.json \u5FC5\u987B\u662F schemaVersion=1 \u4E14 templates \u4E3A\u6570\u7EC4\u7684\u5BF9\u8C61", fieldPath: "templates", sourcePath: "web/assets/rooms/templates.json" }]);
+    }
+    const matches = templates.templates.filter((item) => isObject(item) && item.templateId === layout.templateRef);
+    if (matches.length === 0) {
+      return withProblems(outcome, "checked", [{ stage: "template", code: "TEMPLATE_UNKNOWN", message: `\u623F\u95F4\u6A21\u677F\u672A\u767B\u8BB0\uFF1A${layout.templateRef}`, fieldPath: "layout.templateRef", sourcePath: outcome.sourcePath }]);
+    }
+    if (matches.length !== 1) {
+      return withProblems(outcome, "failed", [{ stage: "template", code: "TEMPLATE_INPUT", message: `\u8FD0\u884C\u5305\u6A21\u677F ${layout.templateRef} \u91CD\u590D\u767B\u8BB0\uFF0C\u5FC5\u987B\u6070\u597D\u4E00\u9879`, fieldPath: "templates", sourcePath: "web/assets/rooms/templates.json" }]);
+    }
+    const placeholder = await readJson("assets/rooms/placeholder-catalog.json");
+    if (!isObject(placeholder) || !Array.isArray(placeholder.assets)) {
+      return withProblems(outcome, "failed", [{ stage: "resources", code: "CATALOG_INPUT", message: "\u8FD0\u884C\u5305 placeholder-catalog.json \u5FC5\u987B\u662F assets \u4E3A\u6570\u7EC4\u7684\u975E null\u3001\u975E\u6570\u7EC4\u5BF9\u8C61", fieldPath: "catalog", sourcePath: "web/assets/rooms/placeholder-catalog.json" }]);
+    }
+    const placement = await importResource("assets/rooms/placement.js");
+    const bindings = await importResource("assets/rooms/bindings.js");
+    const library = await importResource("assets/furniture/catalog.js");
+    if (typeof placement.validatePlacement !== "function" || typeof bindings.resolveRoomBindings !== "function" || typeof library.loadFurnitureCatalog !== "function") {
+      throw new CoreError("ROOM_RESOURCE_READ", "\u8FD0\u884C\u5305\u6821\u9A8C\u6A21\u5757\u7F3A\u5C11\u6240\u9700\u5BFC\u51FA\u51FD\u6570", 500);
+    }
+    const loaded = await library.loadFurnitureCatalog({ fetchJson: async (url) => {
+      const prefix = "/specdev-workbench/assets/furniture/";
+      if (url === prefix + "index.json") return readJson("assets/furniture/index.json");
+      const match = /^\/specdev-workbench\/assets\/furniture\/assets\/([a-z][a-z0-9]*(?:-[a-z0-9]+)*)\/asset\.json$/.exec(url);
+      if (!match) throw new Error(`\u5BB6\u5177\u8D44\u6E90\u5730\u5740\u4E0D\u5728\u56FA\u5B9A\u5305\u5185\u767D\u540D\u5355\uFF1A${url}`);
+      return readJson(`assets/furniture/assets/${match[1]}/asset.json`);
+    } });
+    if (!loaded.ok) return withProblems(outcome, "failed", atStage(loaded.diagnostics, "resources"));
+    if (!loaded.catalog) throw new CoreError("ROOM_RESOURCE_READ", "\u5BB6\u5177\u76EE\u5F55\u8BFB\u53D6\u6210\u529F\u5374\u672A\u8FD4\u56DE\u76EE\u5F55", 500);
+    const catalog = { schemaVersion: 1, assets: [...placeholder.assets, ...loaded.catalog.assets] };
+    stage = "placement";
+    const placed = placement.validatePlacement(matches[0], catalog, layout);
+    if (!placed.ok) return withProblems(outcome, "checked", atStage(placed.diagnostics, stage));
+    stage = "bindings";
+    const resolved = bindings.resolveRoomBindings({ business, layout, catalog });
+    if (!resolved.ok) return withProblems(outcome, "checked", atStage(resolved.diagnostics, stage));
+    stage = "documents";
+    const diagnostics = [];
+    const seenDocs = /* @__PURE__ */ new Set();
+    const seenCharts = /* @__PURE__ */ new Set();
+    for (const entry of resolved.directory) {
+      if (entry.businessId !== businessId) continue;
+      if (entry.kind === "workflow") {
+        if (seenCharts.has(entry.chartId)) continue;
+        seenCharts.add(entry.chartId);
+        if (entry.unavailableReason) {
+          diagnostics.push({ stage: "charts", code: "CHART_UNAVAILABLE", targetId: entry.chartId, message: `\u4E1A\u52A1 ${businessId} \u767B\u8BB0\u7684\u6D41\u7A0B\u56FE ${entry.chartId}\uFF08${entry.title}\uFF09\u5F53\u524D\u4E0D\u53EF\u7528\uFF1A${entry.unavailableReason}` });
+          continue;
+        }
+        let page;
+        try {
+          page = await readChartPage(repoRoot, businessId, entry.chartId, "current");
+        } catch (error) {
+          const causeCode = error instanceof CoreError ? error.code : error?.code;
+          diagnostics.push({ stage: "charts", code: "CHART_UNREADABLE", targetId: entry.chartId, message: `\u6D41\u7A0B\u56FE ${entry.chartId} \u8BFB\u53D6\u5931\u8D25\uFF1A${reasonOf(error)}`, ...causeCode ? { causeCode } : {} });
+          continue;
+        }
+        if (page.version.workflowError || page.version.files.workflow == null) {
+          diagnostics.push({ stage: "charts", code: "CHART_UNREADABLE", targetId: entry.chartId, message: `\u6D41\u7A0B\u56FE ${entry.chartId} \u7684 workflow.json \u7F3A\u5931\u6216\u8BFB\u4E0D\u5F00\uFF1A${page.version.workflowError ?? "readChartPage \u672A\u8FD4\u56DE workflow \u5185\u5BB9"}` });
+          continue;
+        }
+        let workflow;
+        try {
+          workflow = JSON.parse(page.version.files.workflow);
+        } catch (error) {
+          diagnostics.push({ stage: "charts", code: "CHART_JSON_INVALID", targetId: entry.chartId, message: `\u6D41\u7A0B\u56FE ${entry.chartId} \u7684 workflow.json \u4E0D\u662F\u5408\u6CD5 JSON\uFF1A${reasonOf(error)}` });
+          continue;
+        }
+        if (!isObject(workflow)) {
+          diagnostics.push({ stage: "charts", code: "CHART_JSON_INVALID", targetId: entry.chartId, message: `\u6D41\u7A0B\u56FE ${entry.chartId} \u7684 workflow.json \u9876\u5C42\u5FC5\u987B\u662F JSON \u5BF9\u8C61\uFF08\u5B9E\u9645\u662F ${Array.isArray(workflow) ? "\u6570\u7EC4" : typeof workflow}\uFF09` });
+          continue;
+        }
+        continue;
+      }
+      if (seenDocs.has(entry.path)) continue;
+      seenDocs.add(entry.path);
+      try {
+        if (await readWorktreeFileOptional(repoRoot, entry.path) === null) {
+          diagnostics.push({ stage, code: "DOCUMENT_UNREADABLE", sourcePath: entry.path, message: `business.json \u767B\u8BB0\u7684\u8D44\u6599\u4E0D\u5B58\u5728\u6216\u4E0D\u662F\u6587\u4EF6\uFF1A${entry.path}` });
+        }
+      } catch (error) {
+        const causeCode = error instanceof CoreError ? error.code : error?.code;
+        diagnostics.push({ stage, code: "DOCUMENT_UNREADABLE", sourcePath: entry.path, message: `business.json \u767B\u8BB0\u7684\u8D44\u6599\u65E0\u6CD5\u8BFB\u53D6\uFF1A${entry.path}\uFF08${reasonOf(error)}\uFF09`, ...causeCode ? { causeCode } : {} });
+      }
+    }
+    return { ...outcome, kind: "checked", ok: diagnostics.length === 0, diagnostics };
+  } catch (error) {
+    return withProblems(outcome, "failed", [{ stage, code: error instanceof CoreError ? error.code : "internal", message: reasonOf(error) }]);
+  }
+}
+function exitCodeOf(outcome) {
+  return outcome.kind === "failed" ? 2 : outcome.ok ? 0 : 1;
+}
+function formatReport(outcome) {
+  const lines = [`\u623F\u95F4\u6821\u9A8C\uFF1A${outcome.businessId ?? "\uFF08\u4E1A\u52A1\u672A\u89E3\u6790\uFF09"}`, `\u4ED3\u5E93\uFF1A${outcome.repoRoot ?? "\uFF08\u672A\u89E3\u6790\uFF09"}`, `\u914D\u7F6E\uFF1A${outcome.sourcePath ?? "\uFF08\u672A\u89E3\u6790\uFF09"}`];
+  lines.push(outcome.ok ? "\u623F\u95F4\u914D\u7F6E\u4E0E\u767B\u8BB0\u8D44\u6599\u68C0\u67E5\u901A\u8FC7" : outcome.kind === "failed" ? "\u672A\u901A\u8FC7\uFF1A\u65E0\u6CD5\u5B8C\u6210\u6B63\u5E38\u68C0\u67E5" : "\u672A\u901A\u8FC7\uFF1A\u914D\u7F6E\u6216\u767B\u8BB0\u8D44\u6599\u6709\u95EE\u9898");
+  for (const diagnostic of outcome.diagnostics) {
+    lines.push(`[${diagnostic.stage}/${diagnostic.code}] ${diagnostic.message}`);
+    if (diagnostic.fieldPath) lines.push(`  \u5B57\u6BB5\uFF1A${diagnostic.fieldPath}`);
+    if (diagnostic.instanceIds?.length) lines.push(`  \u5B9E\u4F8B\uFF1A${diagnostic.instanceIds.join("\u3001")}`);
+    if (diagnostic.targetId) lines.push(`  \u76EE\u6807\uFF1A${diagnostic.targetId}`);
+    if (diagnostic.sourcePath) lines.push(`  \u6587\u4EF6\uFF1A${diagnostic.sourcePath}`);
+    if (diagnostic.causeCode) lines.push(`  \u5E95\u5C42\u539F\u56E0\u7801\uFF1A${diagnostic.causeCode}`);
+    if (diagnostic.stage === "documents" || diagnostic.stage === "bindings") lines.push("  \u6838\u5BF9\u5F53\u524D\u4E1A\u52A1 business.json \u7684\u8D44\u6599\u767B\u8BB0\u3001\u8D44\u6599\u6587\u4EF6\u53CA room.json \u7ED1\u5B9A\u3002");
+    if (diagnostic.stage === "charts") lines.push("  \u6838\u5BF9\u5F53\u524D\u4E1A\u52A1\u56FE\u76EE\u5F55\u7684 chart.json\u3001workflow.json \u53CA room.json \u7ED1\u5B9A\uFF1B\u56FE\u7684\u65B0\u5EFA\u3001\u4FEE\u6539\u4E0E\u8282\u70B9\u8BE6\u60C5\u5F52 specdev-business\uFF0C\u4E0D\u5728\u672C\u68C0\u67E5\u5185\u3002");
+    if (diagnostic.stage === "resources" || diagnostic.code === "TEMPLATE_INPUT") lines.push("  \u6838\u5BF9\u63D2\u4EF6\u8FD0\u884C\u5305\u8D44\u6E90\uFF1B\u4E0D\u8981\u7528\u6539\u7528\u6237 room.json \u63A9\u76D6\u5305\u8D44\u6E90\u95EE\u9898\u3002");
+  }
+  return lines.join("\n");
+}
+async function main(argv, io) {
+  const jsonCount = argv.filter((arg) => arg === "--json").length;
+  const inputs = argv.filter((arg) => arg !== "--json");
+  const unknown = inputs.filter((arg) => arg.startsWith("-"));
+  let outcome;
+  if (jsonCount > 1 || inputs.length !== 2 || unknown.length > 0 || inputs.some((arg) => arg === "")) {
+    const message = `\u9700\u8981\u4E24\u4E2A\u4F4D\u7F6E\u53C2\u6570\uFF08\u9879\u76EE\u4ED3\u5E93\u6839\u3001\u4E1A\u52A1 ID\uFF09\u548C\u81F3\u591A\u4E00\u6B21 --json\u3002${unknown.length ? `\u672A\u77E5\u53C2\u6570\uFF1A${unknown.join("\u3001")}` : ""}`;
+    outcome = withProblems(initialOutcome(), "failed", [{ stage: "input", code: "bad-request", message }]);
+    io.err(`${message}
+${USAGE}
+`);
+  } else {
+    outcome = await runRoomCheck(inputs[0], inputs[1]);
+  }
+  io.out(`${jsonCount > 0 ? JSON.stringify(outcome, null, 2) : formatReport(outcome)}
+`);
+  return exitCodeOf(outcome);
+}
+if (process.argv[1] !== void 0 && pathToFileURL(process.argv[1]).href === import.meta.url) {
+  process.exitCode = await main(process.argv.slice(2), { out: (text) => process.stdout.write(text), err: (text) => process.stderr.write(text) });
+}
+export {
+  exitCodeOf,
+  formatReport,
+  main,
+  runRoomCheck
+};