@pioneer_zmc/dsh-workbench 0.2.1

package/dist/check-building.js

@@ -0,0 +1,1669 @@
+// 构建产物：由 scripts/build.mjs 从 src/ 生成，请勿手改。
+
+
+// src/cli/check-building.ts
+import path2 from "node:path";
+import { 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 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/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`;
+var BUILDING_FORMAT = "specdev-building";
+var BUILDING_SCHEMA = "specdev/building/1";
+
+// 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 };
+}
+
+// src/core/inventory.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"];
+
+// src/core/fingerprint.ts
+function normalizeEol(text) {
+  return text.replace(/\r\n/g, "\n");
+}
+
+// src/core/chart.ts
+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";
+}
+
+// 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 readdir(`${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 readdir(`${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"];
+
+// src/core/house.ts
+var PHASES = [
+  "design",
+  "foundation",
+  "structure",
+  "enclosure",
+  "services",
+  "interior",
+  "accepted"
+];
+var PROTOTYPES = {
+  foyer: "#708c79",
+  studio: "#4e8586",
+  archive: "#9a8963",
+  review: "#ab7966",
+  observatory: "#728ba9"
+};
+var EPS = 1e-6;
+var SIGN_CLEARANCE = 0.07;
+var round = (n) => Math.round(n * 1e6) / 1e6;
+var eq = (a, b) => Math.abs(a - b) < EPS;
+var positiveOverlap = (a, b, c, d) => Math.min(b, d) - Math.max(a, c) > EPS;
+var overlap = (a, b) => positiveOverlap(a.x0, a.x1, b.x0, b.x1) && positiveOverlap(a.z0, a.z1, b.z0, b.z1);
+var inside = (b, p, margin = 0) => p.x >= b.x0 + margin - EPS && p.x <= b.x1 - margin + EPS && p.z >= b.z0 + margin - EPS && p.z <= b.z1 - margin + EPS;
+var sorted = (xs) => [...xs].sort((a, b) => a.id < b.id ? -1 : a.id > b.id ? 1 : 0);
+var sides = ["north", "south", "east", "west"];
+var boxRect = (r) => ({
+  x0: round(r.x - r.width / 2),
+  x1: round(r.x + r.width / 2),
+  z0: round(r.z - r.depth / 2),
+  z1: round(r.z + r.depth / 2)
+});
+var boundsOf = (bs) => ({
+  x0: Math.min(...bs.map((b) => b.x0)),
+  x1: Math.max(...bs.map((b) => b.x1)),
+  z0: Math.min(...bs.map((b) => b.z0)),
+  z1: Math.max(...bs.map((b) => b.z1))
+});
+var DEFAULT_STATUS = {
+  design: "detailed",
+  approval: "pending",
+  implementation: "unknown",
+  tests: "pending",
+  acceptance: "pending",
+  evidence: {}
+};
+var S = { type: "string" };
+var N = { type: "number" };
+var B = { type: "boolean" };
+var enumeration = (values) => ({ type: "string", enum: values });
+var object = (props, required = Object.keys(props)) => ({
+  type: "object",
+  props,
+  required
+});
+var array = (item) => ({ type: "array", item });
+var idRule = { type: "string", pattern: /^[a-z][a-z0-9-]*$/ };
+var businessIdRule = { type: "string", pattern: /^[A-Za-z0-9][A-Za-z0-9._-]*$/ };
+var statusRule = object({
+  design: enumeration(["concept", "detailed"]),
+  approval: enumeration(["pending", "approved"]),
+  implementation: enumeration(["absent", "unknown", "present"]),
+  tests: enumeration(["pending", "passed"]),
+  acceptance: enumeration(["pending", "passed"]),
+  evidence: object({ implementation: S, tests: S, acceptance: S }, [])
+});
+var endpointRule = object({ spaceId: idRule, x: N, z: N });
+var blueprintRule = object(
+  {
+    format: enumeration([BUILDING_FORMAT]),
+    schema: enumeration([BUILDING_SCHEMA]),
+    units: enumeration(["m"]),
+    style: enumeration(["warm-modern", "chinese-timber"]),
+    defaults: object({ wallThickness: N, slabThickness: N, doorHeight: N }, []),
+    floors: array(object({ id: idRule, name: S, elevation: N, height: N })),
+    spaces: array(
+      object(
+        {
+          id: idRule,
+          name: S,
+          kind: enumeration(["room", "corridor", "terrace", "yard"]),
+          floorId: idRule,
+          rect: object({ x: N, z: N, width: N, depth: N }),
+          businessId: businessIdRule,
+          directory: B,
+          prototype: enumeration(Object.keys(PROTOTYPES)),
+          height: N,
+          accent: { type: "string", pattern: /^#[a-fA-F0-9]{6}$/ },
+          wallType: enumeration(["plaster", "brick", "timber"]),
+          status: statusRule
+        },
+        ["id", "kind", "floorId", "rect"]
+      )
+    ),
+    openings: array(
+      object(
+        {
+          id: idRule,
+          kind: enumeration(["door", "window"]),
+          spaceId: idRule,
+          side: enumeration(sides),
+          offset: N,
+          width: N,
+          height: N,
+          sill: N,
+          to: idRule
+        },
+        ["id", "kind", "spaceId", "side", "offset", "width"]
+      )
+    ),
+    stairs: array(object({ id: idRule, from: endpointRule, to: endpointRule, width: N, steps: N })),
+    roofs: array(
+      object({ id: idRule, spaceIds: array(idRule), type: enumeration(["flat", "gable"]), rise: N, overhang: N }, [
+        "id",
+        "spaceIds",
+        "type"
+      ])
+    ),
+    construction: object({ phase: enumeration(PHASES), status: statusRule }),
+    entry: endpointRule
+  },
+  ["format", "schema", "units", "style", "floors", "spaces", "entry"]
+);
+function validateShape(value, rule, path3, report) {
+  const type = Array.isArray(value) ? "array" : value === null ? "null" : typeof value;
+  if (type !== rule.type || type === "number" && !Number.isFinite(value)) {
+    report("INPUT_TYPE", path3, `\u9700\u8981 ${rule.type} \u7C7B\u578B${rule.type === "number" ? "\u7684\u6709\u9650\u6570\u503C" : ""}\u3002`);
+    return;
+  }
+  if (rule.type === "string") {
+    const text = value;
+    if (rule.enum && !rule.enum.includes(text)) report("INPUT_ENUM", path3, `\u5141\u8BB8\u503C\uFF1A${rule.enum.join("\u3001")}\u3002`);
+    if (rule.pattern && !rule.pattern.test(text)) report("INPUT_PATTERN", path3, "\u683C\u5F0F\u4E0D\u5408\u6CD5\u3002");
+    if (!text.trim()) report("INPUT_EMPTY", path3, "\u5185\u5BB9\u4E0D\u80FD\u4E3A\u7A7A\u3002");
+    return;
+  }
+  if (rule.type === "object") {
+    const record = value;
+    for (const key of Object.keys(record)) {
+      if (!Object.hasOwn(rule.props, key)) {
+        report("INPUT_UNKNOWN_FIELD", `${path3}/${key}`, "\u672A\u5B9A\u4E49\u7684\u5B57\u6BB5\uFF0C\u8BF7\u68C0\u67E5\u62FC\u5199\u6216\u67E5\u9605\u5951\u7EA6\u3002");
+      } else {
+        validateShape(record[key], rule.props[key], `${path3}/${key}`, report);
+      }
+    }
+    for (const key of rule.required) if (!Object.hasOwn(record, key)) report("INPUT_REQUIRED", `${path3}/${key}`, "\u7F3A\u5C11\u5FC5\u586B\u5B57\u6BB5\u3002");
+    return;
+  }
+  if (rule.type === "array") value.forEach((item, i) => validateShape(item, rule.item, `${path3}/${i}`, report));
+}
+function sideOf(space, side) {
+  const b = space.bounds;
+  const alongX = side === "north" || side === "south";
+  return {
+    axis: alongX ? "x" : "z",
+    at: side === "north" ? b.z0 : side === "south" ? b.z1 : side === "west" ? b.x0 : b.x1,
+    lo: alongX ? b.x0 : b.z0,
+    hi: alongX ? b.x1 : b.z1,
+    center: alongX ? space.rect.x : space.rect.z,
+    normal: { x: side === "west" ? 1 : side === "east" ? -1 : 0, y: 0, z: side === "north" ? 1 : side === "south" ? -1 : 0 }
+  };
+}
+function sharedEdge(a, b) {
+  const x = Math.min(a.x1, b.x1) - Math.max(a.x0, b.x0);
+  const z = Math.min(a.z1, b.z1) - Math.max(a.z0, b.z0);
+  if (x > EPS && (eq(a.z1, b.z0) || eq(a.z0, b.z1))) {
+    return { axis: "x", at: eq(a.z1, b.z0) ? a.z1 : a.z0, lo: Math.max(a.x0, b.x0), hi: Math.min(a.x1, b.x1) };
+  }
+  if (z > EPS && (eq(a.x1, b.x0) || eq(a.x0, b.x1))) {
+    return { axis: "z", at: eq(a.x1, b.x0) ? a.x1 : a.x0, lo: Math.max(a.z0, b.z0), hi: Math.min(a.z1, b.z1) };
+  }
+  return null;
+}
+function inWallRange(edge, lo, hi) {
+  return lo >= edge.lo - EPS && hi <= edge.hi + EPS;
+}
+function planeBox(axis, at, lo, hi, y0, y1, thickness) {
+  return {
+    position: { x: axis === "x" ? (lo + hi) / 2 : at, y: (y0 + y1) / 2, z: axis === "z" ? (lo + hi) / 2 : at },
+    size: { x: axis === "x" ? hi - lo : thickness, y: y1 - y0, z: axis === "z" ? hi - lo : thickness }
+  };
+}
+function generateBuilding(input, sources) {
+  const diagnostics = [];
+  const report = (code, path3, message, ids = [], evidence = {}, severity = "error") => {
+    diagnostics.push({ code, severity, message, subject: { path: path3, ids: [...ids] }, evidence });
+  };
+  const fail = () => ({ ok: false, model: null, diagnostics });
+  const errors = () => diagnostics.some((d) => d.severity === "error");
+  const rewriteIndexPaths = (source) => {
+    if (typeof source !== "object" || source === null) return;
+    const record = source;
+    const idAt = (key, index) => {
+      const list = record[key];
+      if (!Array.isArray(list)) return null;
+      const item = list[index];
+      if (typeof item !== "object" || item === null) return null;
+      const id = item.id;
+      return typeof id === "string" ? id : null;
+    };
+    for (const d of diagnostics) {
+      d.subject.path = d.subject.path.replace(
+        /^\/(floors|spaces|openings|stairs|roofs)\/(\d+)(?=\/|$)/,
+        (full, key, index) => {
+          const id = idAt(key, Number(index));
+          return id !== null ? `/${key}/${id}` : full;
+        }
+      );
+    }
+  };
+  validateShape(input, blueprintRule, "", report);
+  if (errors()) {
+    rewriteIndexPaths(input);
+    return fail();
+  }
+  const data = JSON.parse(JSON.stringify(input));
+  const defaults = { wallThickness: 0.18, slabThickness: 0.18, doorHeight: 2.5, ...data.defaults ?? {} };
+  const construction = data.construction ?? { phase: "design", status: structuredClone(DEFAULT_STATUS) };
+  for (const [key, value] of Object.entries(defaults)) {
+    if (!(value > 0 && value <= (key === "doorHeight" ? 8 : 0.6))) {
+      report("DEFAULT_RANGE", `/defaults/${key}`, "\u539A\u5EA6\u5E94\u5728 (0, 0.6] \u7C73\uFF0C\u95E8\u9AD8\u5E94\u5728 (0, 8] \u7C73\u3002");
+    }
+  }
+  if (!data.floors.length || !data.spaces.length) report("EMPTY_BUILDING", "/spaces", "\u81F3\u5C11\u9700\u8981\u4E00\u5C42\u3001\u4E00\u4E2A\u7A7A\u95F4\u3002");
+  if (data.spaces.length > 240 || data.floors.length > 24 || (data.openings ?? []).length > 2e3) {
+    report("INPUT_LIMIT", "/spaces", "\u672C\u7248\u652F\u6301\u6700\u591A 240 \u7A7A\u95F4\u300124 \u5C42\u30012000 \u4E2A\u5F00\u53E3\u3002");
+  }
+  if ((data.stairs ?? []).length > 96 || (data.roofs ?? []).length > 240) {
+    report("INPUT_LIMIT", "", "\u672C\u7248\u6700\u591A\u652F\u6301 96 \u8DD1\u697C\u68AF\u548C 240 \u4E2A\u5C4B\u9876\u3002");
+  }
+  if (errors()) return fail();
+  const paths = /* @__PURE__ */ new Map();
+  const identities = /* @__PURE__ */ new Map();
+  const register = (item, container) => {
+    const path3 = `${container}/${item.id}`;
+    if (identities.has(item.id)) {
+      report("ID_DUPLICATE", `${path3}/id`, "id \u5728\u84DD\u56FE\u5185\u91CD\u590D\u3002", [item.id], { duplicateOf: identities.get(item.id) });
+    } else {
+      identities.set(item.id, path3);
+      paths.set(item.id, path3);
+    }
+  };
+  for (const key of ["floors", "spaces", "openings", "stairs", "roofs"]) {
+    for (const item of data[key] ?? []) register(item, `/${key}`);
+  }
+  const pathOf = (id) => paths.get(id) ?? "";
+  const checkStatus = (status, path3, ids = []) => {
+    for (const key of ["implementation", "tests", "acceptance"]) {
+      if (status[key] === (key === "implementation" ? "present" : "passed") && !(status.evidence[key] ?? "").trim()) {
+        report("STATE_EVIDENCE_REQUIRED", `${path3}/evidence/${key}`, "\u6B64\u58F0\u660E\u5FC5\u987B\u6709\u5BF9\u5E94\u7684\u8BC1\u636E\u51FA\u5904\u3002", ids);
+      }
+    }
+    if ((status.tests === "passed" || status.acceptance === "passed") && status.implementation !== "present") {
+      report("STATE_CONTRADICTION", path3, "\u672A\u58F0\u660E\u6709\u5B9E\u73B0\uFF0C\u4E0D\u80FD\u58F0\u79F0\u5B9E\u73B0\u6D4B\u8BD5\u6216\u4F5C\u8005\u9A8C\u6536\u5DF2\u901A\u8FC7\u3002", ids);
+    }
+    if (status.approval === "approved" && status.design !== "detailed") {
+      report("STATE_CONTRADICTION", path3, "\u672C\u7248\u53EA\u6709\u8BE6\u7EC6\u8BBE\u8BA1\u624D\u80FD\u767B\u8BB0\u6279\u51C6\u3002", ids);
+    }
+  };
+  checkStatus(construction.status, "/construction/status");
+  const floors = sorted(data.floors).map((f) => ({ ...f, y: f.elevation }));
+  const floorMap = new Map(floors.map((f) => [f.id, f]));
+  for (const f of floors) {
+    if (f.height < 2.6 || f.height > 12 || Math.abs(f.y) > 500) {
+      report("FLOOR_RANGE", pathOf(f.id), "\u697C\u5C42\u51C0\u9AD8\u5E94\u5728 2.6\u201412 \u7C73\u4E4B\u95F4\uFF0C\u6807\u9AD8\u7EDD\u5BF9\u503C\u4E0D\u8D85\u8FC7 500 \u7C73\u3002", [f.id]);
+    }
+  }
+  const businessById = new Map(sources.businesses.map((b) => [b.id, b]));
+  const spaces = sorted(data.spaces).map((s) => {
+    const path3 = pathOf(s.id);
+    const f = floorMap.get(s.floorId);
+    if (!f) report("FLOOR_REF", `${path3}/floorId`, "\u697C\u5C42\u4E0D\u5B58\u5728\u3002", [s.id, s.floorId]);
+    if (s.rect.width < 1.6 || s.rect.depth < 1.6 || s.rect.width > 200 || s.rect.depth > 200 || Math.abs(s.rect.x) > 1e3 || Math.abs(s.rect.z) > 1e3) {
+      report("SPACE_DIMENSION", `${path3}/rect`, "\u7A7A\u95F4\u8FB9\u957F\u5E94\u4E3A 1.6\u2014200 \u7C73\uFF0C\u5750\u6807\u7EDD\u5BF9\u503C\u4E0D\u8D85\u8FC7 1000 \u7C73\u3002", [s.id]);
+    }
+    if (s.kind === "room" && !s.businessId) report("BUSINESS_REQUIRED", `${path3}/businessId`, "\u4E1A\u52A1\u623F\u9700\u8981\u7A33\u5B9A\u7684\u4E1A\u52A1 id\u3002", [s.id]);
+    const height = s.height ?? f?.height ?? 3.4;
+    if (height < 2.6 || height > 12) report("SPACE_HEIGHT", `${path3}/height`, "\u7A7A\u95F4\u5899\u9AD8\u5E94\u5728 2.6\u201412 \u7C73\u4E4B\u95F4\u3002", [s.id]);
+    const status = s.status ?? structuredClone(construction.status);
+    if (s.status) checkStatus(status, `${path3}/status`, [s.id]);
+    if (construction.phase === "accepted" && s.kind === "room" && !(status.approval === "approved" && status.implementation === "present" && status.tests === "passed" && status.acceptance === "passed")) {
+      report("ACCEPTANCE_INCOMPLETE", `${path3}/status`, "\u9A8C\u6536\u5165\u4F4F\u9700\u8981\u8BBE\u8BA1\u6279\u51C6\u3001\u5B9E\u73B0\u3001\u6D4B\u8BD5\u548C\u4F5C\u8005\u9A8C\u6536\u8BB0\u5F55\u9F50\u5907\u3002", [s.id]);
+    }
+    const source = s.businessId !== void 0 ? businessById.get(s.businessId) : void 0;
+    const name = s.kind === "room" ? source?.name ?? s.name ?? s.businessId ?? s.id : s.name ?? s.id;
+    return {
+      ...s,
+      name,
+      intro: source?.intro,
+      y: f?.y ?? 0,
+      height,
+      bounds: boxRect(s.rect),
+      prototype: s.prototype ?? "studio",
+      wallType: s.wallType ?? "plaster",
+      accent: s.accent ?? PROTOTYPES[s.prototype ?? "studio"],
+      status
+    };
+  });
+  if (errors()) return fail();
+  const spaceMap = new Map(spaces.map((s) => [s.id, s]));
+  const rooms = spaces.filter((s) => s.kind === "room");
+  for (let i = 0; i < spaces.length; i++) {
+    for (let j = i + 1; j < spaces.length; j++) {
+      const a = spaces[i];
+      const b = spaces[j];
+      if (a.floorId === b.floorId && overlap(a.bounds, b.bounds)) {
+        report("SPACE_OVERLAP", `${pathOf(b.id)}/rect`, "\u540C\u5C42\u7A7A\u95F4\u5185\u90E8\u76F8\u4EA4\uFF1B\u5171\u8FB9\u53EF\u7528\uFF0C\u91CD\u53E0\u4E0D\u53EF\u7528\u3002", [a.id, b.id], {
+          first: a.bounds,
+          second: b.bounds
+        });
+      }
+      if (a.floorId !== b.floorId && overlap(a.bounds, b.bounds) && positiveOverlap(a.y, a.y + a.height + defaults.slabThickness, b.y, b.y + b.height + defaults.slabThickness)) {
+        report("FLOOR_CLEARANCE", pathOf(b.id), "\u4E0A\u4E0B\u7A7A\u95F4\u51C0\u7A7A\u6216\u697C\u677F\u76F8\u4EA4\uFF0C\u8BF7\u8C03\u6574\u6807\u9AD8\u6216\u5899\u9AD8\u3002", [a.id, b.id]);
+      }
+    }
+  }
+  const entrySpace = spaceMap.get(data.entry.spaceId);
+  if (!entrySpace || !inside(entrySpace.bounds, data.entry, 0.35)) {
+    report("ENTRY_POSITION", "/entry", "\u5165\u53E3\u8D77\u70B9\u9700\u4F4D\u4E8E\u5DF2\u767B\u8BB0\u7A7A\u95F4\u5185\uFF0C\u5E76\u4E0E\u8FB9\u7F18\u4FDD\u7559 0.35 \u7C73\u3002", [data.entry.spaceId]);
+  }
+  const entry = { ...data.entry, y: entrySpace?.y ?? 0 };
+  const lines = /* @__PURE__ */ new Map();
+  for (const room of rooms) {
+    for (const side of sides) {
+      const edge = sideOf(room, side);
+      const key = `${room.floorId}|${edge.axis}|${edge.at}`;
+      if (!lines.has(key)) lines.set(key, []);
+      lines.get(key).push({ ...edge, room });
+    }
+  }
+  const walls = [];
+  for (const [key, entries] of [...lines].sort(([a], [b]) => a.localeCompare(b, "en"))) {
+    const cuts = [...new Set(entries.flatMap((e) => [e.lo, e.hi]))].sort((a, b) => a - b);
+    for (let i = 0; i < cuts.length - 1; i++) {
+      const lo = cuts[i];
+      const hi = cuts[i + 1];
+      const owners = entries.filter((e) => e.lo < hi - EPS && e.hi > lo + EPS);
+      if (!owners.length) continue;
+      const room = owners[0].room;
+      if (owners.some((e) => !eq(e.room.height, room.height) || e.room.wallType !== room.wallType)) {
+        report("SHARED_WALL_CONFLICT", pathOf(room.id), "\u5171\u5899\u623F\u95F4\u5FC5\u987B\u4F7F\u7528\u76F8\u540C\u5899\u9AD8\u4E0E\u5899\u6750\u7C7B\u578B\u3002", owners.map((e) => e.room.id));
+      }
+      walls.push({
+        id: `wall:${key}:${lo}:${hi}`,
+        axis: owners[0].axis,
+        at: owners[0].at,
+        lo,
+        hi,
+        y: room.y,
+        height: room.height,
+        floorId: room.floorId,
+        wallType: room.wallType,
+        spaceIds: owners.map((e) => e.room.id).sort(),
+        openings: [],
+        segments: []
+      });
+    }
+  }
+  const openings = [];
+  for (const o of sorted(data.openings ?? [])) {
+    const room = spaceMap.get(o.spaceId);
+    const path3 = pathOf(o.id);
+    if (!room || room.kind !== "room") {
+      report("OPENING_ROOM", `${path3}/spaceId`, "\u5F00\u53E3\u5FC5\u987B\u5F15\u7528\u4E1A\u52A1\u623F\u3002", [o.id, o.spaceId]);
+      continue;
+    }
+    const edge = sideOf(room, o.side);
+    const center = edge.center + o.offset;
+    const lo = center - o.width / 2;
+    const hi = center + o.width / 2;
+    const height = o.height ?? (o.kind === "door" ? defaults.doorHeight : 1.2);
+    const sill = o.sill ?? (o.kind === "door" ? 0 : 1);
+    if (o.width < (o.kind === "door" ? 0.95 : 0.2) || height < 0.2 || o.kind === "door" && height < 2.2 || sill < 0 || sill + height > room.height - 0.12 || !inWallRange({ lo: edge.lo + 0.2, hi: edge.hi - 0.2 }, lo, hi)) {
+      report("OPENING_SIZE", path3, "\u5F00\u53E3\u5C3A\u5BF8\u6216\u4F4D\u7F6E\u8D8A\u754C\uFF0C\u95E8\u9700\u81F3\u5C11\u5BBD 0.95\u3001\u9AD8 2.2 \u7C73\uFF0C\u5899\u89D2\u81F3\u5C11\u7559 0.2 \u7C73\u3002", [o.id]);
+    }
+    if (o.kind === "door") {
+      const target = o.to !== void 0 ? spaceMap.get(o.to) : void 0;
+      const shared = target ? sharedEdge(room.bounds, target.bounds) : null;
+      if (sill !== 0 || !target || target.floorId !== room.floorId || !shared || shared.axis !== edge.axis || !eq(shared.at, edge.at) || !inWallRange(shared, lo, hi)) {
+        report("DOOR_CONNECTION", path3, "\u95E8\u5FC5\u987B\u843D\u5728\u6765\u6E90\u623F\u95F4\u4E0E to \u7A7A\u95F4\u540C\u5C42\u7684\u5171\u8FB9\u4E0A\uFF0C\u4E14\u6CA1\u6709\u95E8\u69DB\u3002", [o.id, room.id, o.to ?? ""].filter(Boolean));
+      }
+    } else if (o.to !== void 0) {
+      report("WINDOW_CONNECTION", `${path3}/to`, "\u7A97\u4E0D\u80FD\u58F0\u660E\u4E3A\u53EF\u901A\u884C\u8FDE\u63A5\u3002", [o.id]);
+    }
+    const wall = walls.find((w) => w.floorId === room.floorId && w.axis === edge.axis && eq(w.at, edge.at) && inWallRange(w, lo, hi));
+    if (!wall) {
+      report("OPENING_PARTITION", path3, "\u5F00\u53E3\u8DE8\u8D8A\u4E86\u5171\u5899\u5206\u533A\u7AEF\u70B9\uFF0C\u8BF7\u8C03\u6574\u4F4D\u7F6E\u3002", [o.id]);
+      continue;
+    }
+    const value = {
+      ...o,
+      axis: edge.axis,
+      at: edge.at,
+      lo,
+      hi,
+      center,
+      height,
+      sill,
+      y: room.y,
+      floorId: room.floorId,
+      wallId: wall.id,
+      position: { x: edge.axis === "x" ? center : edge.at, y: room.y, z: edge.axis === "z" ? center : edge.at },
+      normal: edge.normal
+    };
+    wall.openings.push(value);
+    openings.push(value);
+  }
+  for (const wall of walls) {
+    for (let i = 0; i < wall.openings.length; i++) {
+      for (let j = i + 1; j < wall.openings.length; j++) {
+        const a = wall.openings[i];
+        const b = wall.openings[j];
+        if (positiveOverlap(a.lo, a.hi, b.lo, b.hi) && positiveOverlap(a.sill, a.sill + a.height, b.sill, b.sill + b.height)) {
+          report("OPENING_OVERLAP", pathOf(b.id), "\u540C\u4E00\u5899\u9762\u5F00\u53E3\u91CD\u53E0\uFF1B\u5171\u5899\u7684\u95E8\u53EA\u767B\u8BB0\u4E00\u6B21\u3002", [a.id, b.id]);
+        }
+      }
+    }
+    const cuts = [.../* @__PURE__ */ new Set([wall.lo, wall.hi, ...wall.openings.flatMap((o) => [o.lo, o.hi])])].sort((a, b) => a - b);
+    for (let i = 0; i < cuts.length - 1; i++) {
+      const lo = cuts[i];
+      const hi = cuts[i + 1];
+      const active = wall.openings.filter((o) => positiveOverlap(lo, hi, o.lo, o.hi)).sort((a, b) => a.sill - b.sill);
+      let bottom = 0;
+      for (const o of [...active, { sill: wall.height, height: 0 }]) {
+        if (o.sill > bottom + EPS) {
+          wall.segments.push({
+            id: `${wall.id}:piece:${wall.segments.length}`,
+            ...planeBox(wall.axis, wall.at, lo, hi, wall.y + bottom, wall.y + o.sill, defaults.wallThickness)
+          });
+        }
+        bottom = Math.max(bottom, o.sill + o.height);
+      }
+    }
+  }
+  const stairs = [];
+  for (const s of sorted(data.stairs ?? [])) {
+    const a = spaceMap.get(s.from.spaceId);
+    const b = spaceMap.get(s.to.spaceId);
+    const path3 = pathOf(s.id);
+    if (!a || !b || a.floorId === b.floorId || b.y <= a.y) {
+      report("STAIR_FLOORS", path3, "\u697C\u68AF\u9700\u4ECE\u4F4E\u5C42\u7A7A\u95F4\u8FDE\u5230\u9AD8\u5C42\u7A7A\u95F4\u3002", [s.id]);
+      continue;
+    }
+    if (a.kind === "room" || b.kind === "room") {
+      report("STAIR_ENDPOINT_KIND", path3, "\u697C\u68AF\u7AEF\u70B9\u9700\u8FDE\u63A5\u8D70\u5ECA\u3001\u5E73\u53F0\u6216\u5EAD\u9662\uFF1B\u4E0D\u80FD\u7A7F\u8FC7\u672A\u5F00\u6D1E\u7684\u623F\u95F4\u8FB9\u754C\u3002", [s.id, a.id, b.id]);
+      continue;
+    }
+    const dx = s.to.x - s.from.x;
+    const dz = s.to.z - s.from.z;
+    const length = Math.hypot(dx, dz);
+    const rise = b.y - a.y;
+    if (!eq(dx, 0) && !eq(dz, 0) || length < rise || length < EPS || s.width < 1.2 || s.width > 8 || !Number.isInteger(s.steps) || s.steps < 2 || s.steps > 120) {
+      report("STAIR_GEOMETRY", path3, "\u672C\u7248\u652F\u6301\u5BBD 1.2\u20148 \u7C73\u3001\u5761\u5EA6\u4E0D\u8D85\u8FC7 45\xB0\u30012\u2014120 \u7EA7\u7684\u8F74\u5411\u76F4\u8DD1\u68AF\u3002", [s.id]);
+      continue;
+    }
+    const ux = dx / length;
+    const uz = dz / length;
+    const rect = {
+      x0: Math.min(s.from.x, s.to.x) - Math.abs(uz) * s.width / 2,
+      x1: Math.max(s.from.x, s.to.x) + Math.abs(uz) * s.width / 2,
+      z0: Math.min(s.from.z, s.to.z) - Math.abs(ux) * s.width / 2,
+      z1: Math.max(s.from.z, s.to.z) + Math.abs(ux) * s.width / 2
+    };
+    let landed = true;
+    for (const [space, p, sign] of [
+      [a, s.from, -1],
+      [b, s.to, 1]
+    ]) {
+      for (const lateral of [-s.width / 2, s.width / 2]) {
+        for (const longitudinal of [0, 0.6]) {
+          const q = { x: p.x + ux * sign * longitudinal - uz * lateral, z: p.z + uz * sign * longitudinal + ux * lateral };
+          if (!inside(space.bounds, q)) landed = false;
+        }
+      }
+      if (inside(space.bounds, { x: p.x - ux * sign * 0.1, z: p.z - uz * sign * 0.1 }, 0.01)) landed = false;
+    }
+    if (!landed) {
+      report("STAIR_LANDING", path3, "\u697C\u68AF\u7AEF\u70B9\u5FC5\u987B\u63A5\u5728\u5E73\u53F0\u8FB9\u754C\uFF0C\u5E73\u53F0\u8981\u5BB9\u7EB3\u68AF\u5BBD\u5E76\u5411\u5916\u5EF6\u4F38\u81F3\u5C11 0.6 \u7C73\u3002", [s.id, a.id, b.id]);
+    }
+    for (const space of spaces) {
+      if (overlap(rect, space.bounds) && space.y + space.height > a.y + EPS && space.y - defaults.slabThickness < b.y + 2.2) {
+        report("STAIR_SPACE_INTERSECTION", path3, "\u697C\u68AF\u6295\u5F71\u4E0E\u672C\u7248\u8981\u6C42\u7559\u7A7A\u7684\u68AF\u4E95\u76F8\u4EA4\uFF1B\u8BF7\u5206\u5272\u697C\u677F\u7A7A\u95F4\u907F\u5F00\u68AF\u4E95\u3002", [s.id, space.id]);
+      }
+    }
+    const value = {
+      ...s,
+      from: { ...s.from, y: a.y },
+      to: { ...s.to, y: b.y },
+      bounds: rect,
+      length,
+      rise,
+      ux,
+      uz
+    };
+    for (const other of stairs) {
+      if (overlap(rect, other.bounds)) {
+        const intersection = {
+          x0: Math.max(rect.x0, other.bounds.x0),
+          x1: Math.min(rect.x1, other.bounds.x1),
+          z0: Math.max(rect.z0, other.bounds.z0),
+          z1: Math.min(rect.z1, other.bounds.z1)
+        };
+        const yAt = (stair, x, z) => stair.from.y + ((x - stair.from.x) * stair.ux + (z - stair.from.z) * stair.uz) / stair.length * stair.rise;
+        const gaps = [intersection.x0, intersection.x1].flatMap(
+          (x) => [intersection.z0, intersection.z1].map((z) => yAt(value, x, z) - yAt(other, x, z))
+        );
+        if (Math.min(...gaps) < 2.2 && Math.max(...gaps) > -2.2) {
+          report("STAIR_INTERSECTION", path3, "\u697C\u68AF\u4E4B\u95F4\u4E0D\u8DB3 2.2 \u7C73\u5934\u90E8\u51C0\u7A7A\u3002", [s.id, other.id]);
+        }
+      }
+    }
+    stairs.push(value);
+    if (rise / s.steps > 0.22 || length / s.steps < 0.24) {
+      report("STAIR_COMFORT", path3, "\u8E0F\u6B65\u504F\u9661\u6216\u504F\u7A84\uFF0C\u5EFA\u8BAE\u8C03\u6574\u6B65\u6570\u548C\u6C34\u5E73\u957F\u5EA6\u4EE5\u6539\u5584\u89C2\u611F\u3002", [s.id], {
+        risePerStep: rise / s.steps,
+        runPerStep: length / s.steps
+      }, "warning");
+    }
+  }
+  const navigation = {
+    nodes: spaces.map((s) => ({ id: s.id, x: s.rect.x, y: s.y, z: s.rect.z })),
+    edges: []
+  };
+  const connect = (a, b, kind, via) => {
+    navigation.edges.push({ from: a, to: b, kind, via });
+  };
+  for (let i = 0; i < spaces.length; i++) {
+    for (let j = i + 1; j < spaces.length; j++) {
+      const a = spaces[i];
+      const b = spaces[j];
+      const edge = sharedEdge(a.bounds, b.bounds);
+      if (a.kind !== "room" && b.kind !== "room" && a.floorId === b.floorId && edge && edge.hi - edge.lo >= 0.9) {
+        connect(a.id, b.id, "open", null);
+      }
+    }
+  }
+  for (const door of openings) {
+    if (door.kind === "door" && door.to !== void 0 && spaceMap.has(door.to)) connect(door.spaceId, door.to, "door", door.id);
+  }
+  for (const stair of stairs) connect(stair.from.spaceId, stair.to.spaceId, "stair", stair.id);
+  const seen = new Set(entrySpace ? [entrySpace.id] : []);
+  const queue = [...seen];
+  for (let i = 0; i < queue.length; i++) {
+    for (const edge of navigation.edges) {
+      const neighbor = edge.from === queue[i] ? edge.to : edge.to === queue[i] ? edge.from : null;
+      if (neighbor && !seen.has(neighbor)) {
+        seen.add(neighbor);
+        queue.push(neighbor);
+      }
+    }
+  }
+  for (const space of spaces) {
+    if (!seen.has(space.id)) report("SPACE_UNREACHABLE", pathOf(space.id), "\u6309\u95E8\u548C\u697C\u68AF\u8FDE\u63A5\u4ECE\u5165\u53E3\u65E0\u6CD5\u5230\u8FBE\u6B64\u7A7A\u95F4\u3002", [space.id]);
+  }
+  const roofs = [];
+  for (const r of sorted(data.roofs ?? [])) {
+    const path3 = pathOf(r.id);
+    const selected = r.spaceIds.map((id) => spaceMap.get(id));
+    if (!selected.length || selected.some((s) => !s) || new Set(r.spaceIds).size !== r.spaceIds.length) {
+      report("ROOF_REFS", `${path3}/spaceIds`, "\u5C4B\u9876\u9700\u5F15\u7528\u4E0D\u91CD\u590D\u7684\u73B0\u6709\u7A7A\u95F4\u3002", [r.id]);
+      continue;
+    }
+    const picked = selected;
+    const bounds2 = boundsOf(picked.map((s) => s.bounds));
+    const first = picked[0];
+    const base = first.y + first.height;
+    const area = picked.reduce((sum, s) => sum + s.rect.width * s.rect.depth, 0);
+    const enclosingArea = (bounds2.x1 - bounds2.x0) * (bounds2.z1 - bounds2.z0);
+    if (picked.some((s) => s.floorId !== first.floorId || !eq(s.y + s.height, base)) || Math.abs(area - enclosingArea) > EPS) {
+      report("ROOF_RECTANGLE", path3, "\u672C\u7248\u5C4B\u9876\u8986\u76D6\u5FC5\u987B\u662F\u540C\u5C42\u3001\u540C\u5899\u9AD8\u4E14\u65E0\u7A7A\u6D1E\u7684\u5B8C\u6574\u77E9\u5F62\u3002", [r.id]);
+    }
+    const overhang = r.overhang ?? 0.35;
+    const rise = r.type === "gable" ? r.rise ?? 1.8 : 0;
+    if (overhang < 0 || overhang > 2 || r.type === "gable" && (rise <= 0 || rise > 8) || r.type === "flat" && r.rise !== void 0 && r.rise !== 0) {
+      report("ROOF_SIZE", path3, "\u6311\u6A90\u8303\u56F4\u4E3A 0\u20142 \u7C73\uFF0C\u5761\u9876\u5347\u9AD8\u4E3A (0, 8] \u7C73\uFF0C\u5E73\u9876\u4E0D\u8BBE\u7F6E rise\u3002", [r.id]);
+    }
+    const expanded = {
+      x0: bounds2.x0 - overhang,
+      x1: bounds2.x1 + overhang,
+      z0: bounds2.z0 - overhang,
+      z1: bounds2.z1 + overhang
+    };
+    for (const s of spaces) {
+      if (s.y > first.y + EPS && overlap(expanded, s.bounds) && s.y - defaults.slabThickness < base + rise + 0.2) {
+        report("ROOF_UPPER_FLOOR", path3, "\u5C4B\u9876\u7A7F\u5165\u4E0A\u65B9\u697C\u5C42\uFF0C\u8BF7\u6539\u4E3A\u9876\u5C42\u5C4B\u9876\u6216\u8C03\u6574\u8303\u56F4\u3002", [r.id, s.id]);
+      }
+    }
+    for (const other of roofs) {
+      if (overlap(expanded, other.bounds) && positiveOverlap(base - 0.1, base + rise + 0.2, other.base - 0.1, other.base + other.rise + 0.2)) {
+        report("ROOF_INTERSECTION", path3, "\u5C4B\u9876\u5305\u7EDC\u76F8\u4EA4\uFF1B\u672C\u7248\u4E0D\u81EA\u52A8\u5904\u7406\u4EA4\u63A5\u5C4B\u810A\u3002", [r.id, other.id]);
+      }
+    }
+    roofs.push({ ...r, rise, overhang, bounds: expanded, base, floorId: first.floorId });
+  }
+  for (const room of rooms) {
+    if (!roofs.some(
+      (r) => inside(r.bounds, { x: room.bounds.x0, z: room.bounds.z0 }) && inside(r.bounds, { x: room.bounds.x1, z: room.bounds.z1 }) && r.base >= room.y + room.height - EPS
+    )) {
+      report("ROOF_MISSING", pathOf(room.id), "\u6B64\u623F\u95F4\u4E0A\u65B9\u672A\u767B\u8BB0\u5B8C\u6574\u8986\u76D6\u7684\u5C4B\u9876\uFF0C\u4ECD\u53EF\u751F\u6210\u8BBE\u8BA1\u6846\u67B6\u3002", [room.id], {}, "warning");
+    }
+  }
+  if (errors()) return fail();
+  const floorJoints = [];
+  const elevations = [...new Set(floors.map((f) => f.y))].sort((a, b) => a - b);
+  for (const lower of rooms) {
+    const nextY = elevations.find((y) => y > lower.y + EPS);
+    if (nextY === void 0) continue;
+    const y0 = round(lower.y + lower.height);
+    const y1 = round(nextY - defaults.slabThickness);
+    if (y1 - y0 <= EPS) continue;
+    for (const upper of spaces) {
+      if (!eq(upper.y, nextY) || !overlap(lower.bounds, upper.bounds)) continue;
+      floorJoints.push({
+        id: `floor-joint:${lower.id}:${upper.id}`,
+        lowerSpaceId: lower.id,
+        upperSpaceId: upper.id,
+        lowerFloorId: lower.floorId,
+        upperFloorId: upper.floorId,
+        y0,
+        y1,
+        upperY: nextY,
+        bounds: {
+          x0: Math.max(lower.bounds.x0, upper.bounds.x0),
+          x1: Math.min(lower.bounds.x1, upper.bounds.x1),
+          z0: Math.max(lower.bounds.z0, upper.bounds.z0),
+          z1: Math.min(lower.bounds.z1, upper.bounds.z1)
+        }
+      });
+    }
+  }
+  const signs = [
+    {
+      id: "project-sign",
+      title: sources.project.name,
+      subtitle: sources.project.description || "\u9879\u76EE\u5165\u53E3",
+      position: { x: entry.x, y: entry.y + 2.6, z: entry.z },
+      normal: { x: 0, y: 0, z: 1 }
+    }
+  ];
+  for (const room of rooms) {
+    const door = openings.find((o) => o.kind === "door" && (o.spaceId === room.id || o.to === room.id));
+    if (!door) continue;
+    const normal = door.spaceId === room.id ? { x: -door.normal.x, y: 0, z: -door.normal.z } : door.normal;
+    const signGap = defaults.wallThickness / 2 + SIGN_CLEARANCE;
+    signs.push({
+      id: `sign:${room.id}`,
+      spaceId: room.id,
+      floorId: room.floorId,
+      title: room.name,
+      subtitle: room.intro ?? room.businessId,
+      position: { x: door.position.x + normal.x * signGap, y: room.y + door.height + 0.27, z: door.position.z + normal.z * signGap },
+      normal
+    });
+  }
+  const bounds = {
+    ...boundsOf([...spaces.map((s) => s.bounds), ...roofs.map((r) => r.bounds), ...stairs.map((s) => s.bounds)]),
+    y0: Math.min(...spaces.map((s) => s.y)) - defaults.slabThickness,
+    y1: Math.max(...spaces.map((s) => s.y + s.height), ...roofs.map((r) => r.base + r.rise + 0.2))
+  };
+  const model = {
+    format: "specdev-building-model",
+    generator: BUILDING_SCHEMA,
+    project: { name: sources.project.name, description: sources.project.description },
+    style: data.style,
+    defaults,
+    construction,
+    floors,
+    spaces,
+    rooms,
+    walls,
+    doors: openings.filter((o) => o.kind === "door"),
+    openings,
+    stairs,
+    roofs,
+    floorJoints,
+    signs,
+    entry,
+    bounds,
+    navigation,
+    diagnostics
+  };
+  return { ok: true, model, diagnostics };
+}
+
+// src/core/building.ts
+async function readBuildingBlueprint(repoRoot) {
+  const text = await readWorktreeFileOptional(repoRoot, BUILDING_BLUEPRINT_REL);
+  if (text === null) {
+    throw new CoreError(
+      "no-building-blueprint",
+      `\u8BE5\u9879\u76EE\u8FD8\u6CA1\u6709\u5EFA\u7B51\u84DD\u56FE\uFF1A\u672A\u627E\u5230 ${BUILDING_BLUEPRINT_REL}\u3002\u4E0D\u4F1A\u81EA\u52A8\u521B\u5EFA\uFF1B\u84DD\u56FE\u63CF\u8FF0\u7A7A\u95F4\u5B89\u6392\uFF0C\u4E1A\u52A1\u4E0E\u8D44\u6599\u5185\u5BB9\u4EE5\u9879\u76EE\u6E05\u5355\u4E3A\u51C6\u3002`,
+      404
+    );
+  }
+  let data;
+  try {
+    data = JSON.parse(text);
+  } catch (error) {
+    throw new CoreError("bad-blueprint", `${BUILDING_BLUEPRINT_REL} \u4E0D\u662F\u5408\u6CD5 JSON\uFF1A${error.message}`, 500);
+  }
+  if (typeof data !== "object" || data === null || Array.isArray(data) || data.format !== BUILDING_FORMAT || data.schema !== BUILDING_SCHEMA) {
+    throw new CoreError(
+      "bad-blueprint",
+      `${BUILDING_BLUEPRINT_REL} \u7684\u683C\u5F0F\u5934\u5FC5\u987B\u662F format=${BUILDING_FORMAT}\u3001schema=${BUILDING_SCHEMA}`,
+      500
+    );
+  }
+  return data;
+}
+function extractSpaces(blueprint, problems) {
+  const rawSpaces = blueprint.spaces;
+  if (!Array.isArray(rawSpaces)) {
+    problems.push({
+      code: "BLUEPRINT_SHAPE",
+      severity: "error",
+      message: `${BUILDING_BLUEPRINT_REL} \u7F3A\u5C11 spaces \u6570\u7EC4\uFF08\u7A7A\u95F4\u5B89\u6392\u65E0\u6CD5\u6838\u5BF9\u7ED1\u5B9A\uFF09\u3002`,
+      subject: { path: "/spaces", ids: [] }
+    });
+    return [];
+  }
+  const spaces = [];
+  const seen = /* @__PURE__ */ new Map();
+  rawSpaces.forEach((raw, index) => {
+    if (typeof raw !== "object" || raw === null || typeof raw.id !== "string" || raw.id === "") {
+      problems.push({
+        code: "BLUEPRINT_SHAPE",
+        severity: "error",
+        message: `spaces/${index} \u4E0D\u662F\u5E26\u975E\u7A7A id \u7684\u5BF9\u8C61\uFF0C\u65E0\u6CD5\u53C2\u4E0E\u7ED1\u5B9A\u6838\u5BF9\u3002`,
+        subject: { path: `/spaces/${index}`, ids: [] }
+      });
+      return;
+    }
+    const space = raw;
+    const first = seen.get(space.id);
+    if (first !== void 0) {
+      problems.push({
+        code: "BLUEPRINT_SHAPE",
+        severity: "error",
+        message: `\u7A7A\u95F4 id ${space.id} \u5728\u84DD\u56FE\u5185\u91CD\u590D\u3002`,
+        subject: { path: `/spaces/${index}/id`, ids: [space.id] },
+        evidence: { firstAt: `/spaces/${first}/id` }
+      });
+      return;
+    }
+    seen.set(space.id, index);
+    spaces.push(space);
+  });
+  return spaces;
+}
+function checkBusinessBinding(inventory, blueprint) {
+  const problems = [];
+  const spaces = extractSpaces(blueprint, problems);
+  for (const space of spaces) {
+    if (space.directory !== void 0 && typeof space.directory !== "boolean") {
+      problems.push({
+        code: "BLUEPRINT_SHAPE",
+        severity: "error",
+        message: `\u7A7A\u95F4 ${space.id} \u7684 directory \u5FC5\u987B\u662F\u5E03\u5C14\u503C\uFF08\u7F3A\u7701\u89C6\u4E3A\u5F00\u542F\uFF09\uFF1B\u6536\u5230 ${JSON.stringify(space.directory)}\u3002`,
+        subject: { path: `/spaces/${space.id}/directory`, ids: [space.id] },
+        evidence: { got: JSON.stringify(space.directory) }
+      });
+    }
+  }
+  const businessById = new Map(inventory.businesses.map((b) => [b.id, b]));
+  const rooms = [];
+  const boundSpaces = /* @__PURE__ */ new Map();
+  for (const space of spaces) {
+    const kind = typeof space.kind === "string" ? space.kind : "";
+    const hasBusiness = typeof space.businessId === "string" && space.businessId !== "";
+    if (kind !== "room") {
+      if (hasBusiness) {
+        problems.push({
+          code: "BUSINESS_NOT_ROOM",
+          severity: "error",
+          message: `\u7A7A\u95F4 ${space.id} \u4E0D\u662F room\uFF0C\u4E0D\u80FD\u643A\u5E26 businessId\uFF08\u7B2C\u4E00\u671F\u4E1A\u52A1\u8EAB\u4EFD\u53EA\u843D\u5728\u623F\u95F4\u4E0A\uFF09\u3002`,
+          subject: { path: `/spaces/${space.id}/businessId`, ids: [space.id, space.businessId] }
+        });
+      }
+      continue;
+    }
+    if (!hasBusiness) {
+      problems.push({
+        code: "BUSINESS_REQUIRED",
+        severity: "error",
+        message: `\u623F\u95F4 ${space.id} \u7F3A\u5C11 businessId\uFF1B\u7B2C\u4E00\u671F\u4E00\u4E1A\u52A1\u4E00\u623F\u95F4\uFF0C\u6BCF\u95F4\u4E1A\u52A1\u623F\u90FD\u8981\u7ED1\u5B9A\u6E05\u5355\u91CC\u7684\u4E1A\u52A1\u3002`,
+        subject: { path: `/spaces/${space.id}/businessId`, ids: [space.id] }
+      });
+      continue;
+    }
+    const businessId = space.businessId;
+    const business = businessById.get(businessId);
+    if (!business) {
+      problems.push({
+        code: "BUSINESS_UNKNOWN",
+        severity: "error",
+        message: `\u623F\u95F4 ${space.id} \u7ED1\u5B9A\u7684\u4E1A\u52A1 ${businessId} \u4E0D\u5728\u9879\u76EE\u6E05\u5355\uFF08docs/specdev/ \u7684\u4E1A\u52A1\u76EE\u5F55\uFF09\u91CC\u3002`,
+        subject: { path: `/spaces/${space.id}/businessId`, ids: [businessId, space.id] }
+      });
+      continue;
+    }
+    const firstSpace = boundSpaces.get(businessId);
+    if (firstSpace !== void 0) {
+      problems.push({
+        code: "BUSINESS_DUPLICATE",
+        severity: "error",
+        message: `\u4E1A\u52A1 ${businessId} \u88AB\u623F\u95F4 ${firstSpace} \u4E0E ${space.id} \u91CD\u590D\u7ED1\u5B9A\uFF1B\u7B2C\u4E00\u671F\u4E00\u4E1A\u52A1\u4E00\u623F\u95F4\u3002`,
+        subject: { path: `/spaces/${space.id}/businessId`, ids: [businessId, firstSpace, space.id] },
+        evidence: { firstAt: `/spaces/${firstSpace}/businessId` }
+      });
+      continue;
+    }
+    boundSpaces.set(businessId, space.id);
+    rooms.push({
+      spaceId: space.id,
+      spaceName: space.name,
+      floorId: space.floorId,
+      businessId,
+      businessName: business.name,
+      directory: space.directory !== false
+    });
+  }
+  for (const business of inventory.businesses) {
+    if (!boundSpaces.has(business.id)) {
+      problems.push({
+        code: "BUSINESS_MISSING",
+        severity: "error",
+        message: `\u6E05\u5355\u4E1A\u52A1 ${business.id}\uFF08${business.name}\uFF09\u5728\u84DD\u56FE\u91CC\u6CA1\u6709\u5BF9\u5E94\u623F\u95F4\uFF1B\u6362\u5E03\u5C40\u4E0D\u80FD\u5220\u51CF\u9879\u76EE\u4E1A\u52A1\u3002`,
+        subject: { path: "/spaces", ids: [business.id] },
+        evidence: { businessName: business.name }
+      });
+    }
+  }
+  return { problems, rooms };
+}
+function materialKey(entry) {
+  return entry.kind === "document" ? `doc:${entry.businessId}:${entry.path ?? ""}` : `chart:${entry.businessId}:${entry.chartId ?? ""}`;
+}
+async function buildReadingCatalog(repoRoot, inventory, rooms) {
+  const problems = [];
+  const businesses = [];
+  const roomByBusiness = new Map(rooms.map((room) => [room.businessId, room]));
+  const reportUnreadable = (businessId, evidence, reason) => {
+    problems.push({
+      code: "MATERIAL_UNREADABLE",
+      severity: "error",
+      message: `\u4E1A\u52A1 ${businessId} \u7684\u8D44\u6599\u65E0\u6CD5\u9605\u8BFB\uFF1A${reason}`,
+      subject: { path: "", ids: [businessId] },
+      evidence: { ...evidence, reason }
+    });
+  };
+  for (const business of inventory.businesses) {
+    const room = roomByBusiness.get(business.id);
+    if (!room) continue;
+    const entries = [];
+    if (business.descriptorError) {
+      reportUnreadable(
+        business.id,
+        { businessId: business.id },
+        `\u4E1A\u52A1\u8BF4\u660E\u6587\u4EF6\u6709\u95EE\u9898\uFF08${business.descriptorError}\uFF09\uFF0C\u8D44\u6599\u6E05\u5355\u4E0D\u53EF\u4FE1\uFF1B\u4E0D\u80FD\u5F53\u4F5C\u6CA1\u6709\u8D44\u6599\u7EE7\u7EED\u751F\u6210`
+      );
+    }
+    if (room.directory) {
+      for (const docPath of business.docs) {
+        let reason = null;
+        try {
+          const text = await readWorktreeFileOptional(repoRoot, docPath);
+          if (text === null) reason = `\u767B\u8BB0\u7684\u6587\u6863\u4E0D\u5B58\u5728\uFF08\u5DE5\u4F5C\u533A\uFF09\uFF1A${docPath}`;
+        } catch (error) {
+          reason = error instanceof CoreError ? error.message : `\u8BFB\u53D6\u6587\u6863 ${docPath} \u5931\u8D25\uFF1A${String(error)}`;
+        }
+        if (reason) reportUnreadable(business.id, { kind: "document", businessId: business.id, path: docPath }, reason);
+        entries.push({
+          kind: "document",
+          businessId: business.id,
+          path: docPath,
+          title: docPath,
+          href: `/specdev-workbench/api/doc?business=${encodeURIComponent(business.id)}&path=${encodeURIComponent(docPath)}`
+        });
+      }
+      for (const chart of business.charts) {
+        const workflowRel = `${CONVENTION_ROOT}/${business.id}/${chart.id}/workflow.json`;
+        let reason = chart.descriptorError ? `\u56FE\u8BF4\u660E\u6587\u4EF6\u6709\u95EE\u9898\uFF08${chart.descriptorError}\uFF09` : chart.idConflict ? `\u56FE\u7F16\u53F7\u51B2\u7A81\uFF1A${chart.idConflict}` : null;
+        if (!reason) {
+          try {
+            const text = await readWorktreeFileOptional(repoRoot, workflowRel);
+            if (text === null) reason = "\u56FE\u76EE\u5F55\u7F3A\u5C11 workflow.json\uFF0C\u65E0\u6CD5\u9605\u8BFB";
+          } catch (error) {
+            reason = error instanceof CoreError ? error.message : `\u8BFB\u53D6 ${workflowRel} \u5931\u8D25\uFF1A${String(error)}`;
+          }
+        }
+        if (reason) reportUnreadable(business.id, { kind: "workflow", businessId: business.id, chartId: chart.id }, reason);
+        entries.push({
+          kind: "workflow",
+          businessId: business.id,
+          chartId: chart.id,
+          title: chart.descriptorError ? chart.id : chart.name,
+          href: `/specdev-workbench/read/${encodeURIComponent(business.id)}/${encodeURIComponent(chart.id)}`
+        });
+      }
+    }
+    businesses.push({ businessId: business.id, businessName: business.name, spaceId: room.spaceId, entries });
+  }
+  return { problems, catalog: { mode: "room-directory", businesses } };
+}
+function checkCatalogCoverage(inventory, catalog, boundBusinessIds = new Set(catalog.businesses.map((b) => b.businessId))) {
+  const problems = [];
+  const covered = /* @__PURE__ */ new Set();
+  for (const business of catalog.businesses) {
+    for (const entry of business.entries) covered.add(materialKey(entry));
+  }
+  for (const business of inventory.businesses) {
+    if (!boundBusinessIds.has(business.id)) continue;
+    for (const docPath of business.docs) {
+      const key = `doc:${business.id}:${docPath}`;
+      if (!covered.has(key)) {
+        problems.push({
+          code: "MATERIAL_NO_ENTRY",
+          severity: "error",
+          message: `\u4E1A\u52A1 ${business.id} \u7684\u6587\u6863 ${docPath} \u6CA1\u6709\u4EFB\u4F55\u9605\u8BFB\u5165\u53E3\uFF1B\u6BCF\u4E2A\u4E1A\u52A1\u7684\u6587\u6863\u4E0E\u6D41\u7A0B\u56FE\u90FD\u5FC5\u987B\u53EF\u4EE5\u4ECE\u623F\u5185\u8D44\u6599\u76EE\u5F55\u8BBF\u95EE\u3002`,
+          subject: { path: "/spaces", ids: [business.id] },
+          evidence: { kind: "document", businessId: business.id, path: docPath }
+        });
+      }
+    }
+    for (const chart of business.charts) {
+      const key = `chart:${business.id}:${chart.id}`;
+      if (!covered.has(key)) {
+        problems.push({
+          code: "MATERIAL_NO_ENTRY",
+          severity: "error",
+          message: `\u4E1A\u52A1 ${business.id} \u7684\u56FE ${chart.id} \u6CA1\u6709\u4EFB\u4F55\u9605\u8BFB\u5165\u53E3\uFF1B\u6BCF\u4E2A\u4E1A\u52A1\u7684\u6587\u6863\u4E0E\u6D41\u7A0B\u56FE\u90FD\u5FC5\u987B\u53EF\u4EE5\u4ECE\u623F\u5185\u8D44\u6599\u76EE\u5F55\u8BBF\u95EE\u3002`,
+          subject: { path: "/spaces", ids: [business.id] },
+          evidence: { kind: "workflow", businessId: business.id, chartId: chart.id }
+        });
+      }
+    }
+  }
+  return problems;
+}
+async function readBuildingBinding(repoRoot) {
+  const inventory = await readInventory(repoRoot);
+  const blueprint = await readBuildingBlueprint(repoRoot);
+  const binding = checkBusinessBinding(inventory, blueprint);
+  const built = await buildReadingCatalog(repoRoot, inventory, binding.rooms);
+  const coverage = checkCatalogCoverage(inventory, built.catalog);
+  const problems = [...binding.problems, ...built.problems, ...coverage];
+  let model = null;
+  if (problems.every((p) => p.severity !== "error")) {
+    const sources = {
+      project: { name: inventory.project.name, description: inventory.project.description },
+      businesses: inventory.businesses.map((b) => ({ id: b.id, name: b.name, intro: b.intro }))
+    };
+    const generation = generateBuilding(blueprint, sources);
+    problems.push(
+      ...generation.diagnostics.map(
+        (d) => ({
+          code: d.code,
+          severity: d.severity,
+          message: d.message,
+          subject: d.subject,
+          evidence: d.evidence ?? {}
+        })
+      )
+    );
+    if (generation.ok) model = generation.model;
+  }
+  return {
+    ok: problems.every((p) => p.severity !== "error"),
+    blueprintPath: BUILDING_BLUEPRINT_REL,
+    rooms: binding.rooms,
+    catalog: built.catalog,
+    problems,
+    model
+  };
+}
+
+// src/core/diagnosis.ts
+var FIX_TARGET_LABELS = {
+  blueprint: "\u6539\u84DD\u56FE",
+  inventory: "\u6539\u6E05\u5355\u6216\u8D44\u6599",
+  evidence: "\u6309\u8BC1\u636E\u5224"
+};
+var FIX_TARGETS = {
+  // 输入形状（拼写、取值、必填）——蓝图自己写错了
+  INPUT_TYPE: "blueprint",
+  INPUT_ENUM: "blueprint",
+  INPUT_PATTERN: "blueprint",
+  INPUT_EMPTY: "blueprint",
+  INPUT_UNKNOWN_FIELD: "blueprint",
+  INPUT_REQUIRED: "blueprint",
+  DEFAULT_RANGE: "blueprint",
+  EMPTY_BUILDING: "blueprint",
+  INPUT_LIMIT: "blueprint",
+  ID_DUPLICATE: "blueprint",
+  // 状态声明——不许凭空声称已实现/已验收，改法在蓝图（去掉声明或补出处）
+  STATE_EVIDENCE_REQUIRED: "blueprint",
+  STATE_CONTRADICTION: "blueprint",
+  ACCEPTANCE_INCOMPLETE: "blueprint",
+  // 楼层、空间、尺寸、排布
+  FLOOR_REF: "blueprint",
+  FLOOR_RANGE: "blueprint",
+  SPACE_DIMENSION: "blueprint",
+  SPACE_HEIGHT: "blueprint",
+  SPACE_OVERLAP: "blueprint",
+  FLOOR_CLEARANCE: "blueprint",
+  SPACE_UNREACHABLE: "blueprint",
+  ENTRY_POSITION: "blueprint",
+  SHARED_WALL_CONFLICT: "blueprint",
+  // 开口（门、窗）与楼梯
+  OPENING_ROOM: "blueprint",
+  OPENING_SIZE: "blueprint",
+  DOOR_CONNECTION: "blueprint",
+  WINDOW_CONNECTION: "blueprint",
+  OPENING_PARTITION: "blueprint",
+  OPENING_OVERLAP: "blueprint",
+  STAIR_FLOORS: "blueprint",
+  STAIR_ENDPOINT_KIND: "blueprint",
+  STAIR_GEOMETRY: "blueprint",
+  STAIR_LANDING: "blueprint",
+  STAIR_SPACE_INTERSECTION: "blueprint",
+  STAIR_INTERSECTION: "blueprint",
+  STAIR_COMFORT: "blueprint",
+  // 屋顶
+  ROOF_REFS: "blueprint",
+  ROOF_RECTANGLE: "blueprint",
+  ROOF_SIZE: "blueprint",
+  ROOF_UPPER_FLOOR: "blueprint",
+  ROOF_INTERSECTION: "blueprint",
+  ROOF_MISSING: "blueprint",
+  // 绑定层：业务与蓝图之间的对账
+  BLUEPRINT_SHAPE: "blueprint",
+  BUSINESS_REQUIRED: "blueprint",
+  BUSINESS_NOT_ROOM: "blueprint",
+  BUSINESS_DUPLICATE: "blueprint",
+  // 清单里有没有这个业务、业务该不该留，是作者的取舍，按证据判
+  BUSINESS_MISSING: "evidence",
+  BUSINESS_UNKNOWN: "evidence",
+  // 有绑定但没入口：装配被 directory:false 关掉，或（未来）装配漂移——改蓝图
+  MATERIAL_NO_ENTRY: "blueprint",
+  // 资料本身读不了（文档不在/读不开、workflow.json 缺失或读不开、业务/图说明文件坏、图编号冲突）
+  MATERIAL_UNREADABLE: "inventory"
+};
+var LOCATE_HINTS = {
+  MATERIAL_NO_ENTRY: "\u7528 evidence.businessId \u627E\u5230\u5BF9\u5E94\u623F\u95F4\uFF0C\u68C0\u67E5\u5B83\u7684 directory \u662F\u5426\u88AB\u5173\u6389\uFF08\u5173\u6389\u5C31\u6CA1\u6709\u8D44\u6599\u5165\u53E3\uFF09\u3002",
+  BUSINESS_MISSING: 'subject.ids \u91CC\u662F"\u6CA1\u6709\u623F\u95F4\u7684\u4E1A\u52A1 id"\uFF1A\u9ED8\u8BA4\u5728\u84DD\u56FE\u91CC\u7ED9\u5B83\u52A0\u4E00\u95F4\uFF1B\u8FD9\u4E2A\u4E1A\u52A1\u8BE5\u4E0D\u8BE5\u7559\u5728\u6E05\u5355\u91CC\u7531\u4F5C\u8005\u51B3\u5B9A\u3002',
+  BUSINESS_UNKNOWN: "\u5BF9\u7167 subject.ids\uFF08\u4E1A\u52A1 id \u4E0E\u7A7A\u95F4 id\uFF09\u4E0E\u9879\u76EE\u6E05\u5355\uFF1A\u591A\u6570\u662F\u84DD\u56FE\u628A\u4E1A\u52A1 id \u5199\u9519\u4E86\uFF0C\u5148\u6539\u84DD\u56FE\u6307\u5411\u6E05\u5355\u91CC\u7684\u771F\u5B9E id\u3002",
+  MATERIAL_UNREADABLE: "\u6309 evidence \u91CC\u7684 path\uFF0FchartId\uFF0Freason \u6838\u5BF9\u8D44\u6599\u6587\u4EF6\u672C\u8EAB\uFF1A\u8FD9\u7C7B\u6539\u84DD\u56FE\u89E3\u51B3\u4E0D\u4E86\u3002"
+};
+
+// src/cli/check-building.ts
+var EXIT_OK = 0;
+var EXIT_PROBLEMS = 1;
+var EXIT_UNREADABLE = 2;
+var USAGE = "\u7528\u6CD5\uFF1Anode dist/check-building.js <\u9879\u76EE\u4ED3\u5E93\u6839> [--json]";
+var FAILURE_HINTS = {
+  "no-convention-root": "\u8FD9\u91CC\u8FD8\u6CA1\u6709\u4E1A\u52A1\u6E05\u5355\uFF08docs/specdev/project.json\uFF09\uFF1A\u5148\u505A\u4E1A\u52A1\u6E05\u5355\uFF0C\u518D\u5EFA\u623F\u3002",
+  "no-building-blueprint": "\u84DD\u56FE\u8FD8\u4E0D\u5B58\u5728\u2014\u2014docs/specdev/building.json \u6B63\u662F\u5EFA\u623F\u4EFB\u52A1\u8981\u5199\u7684\u6587\u4EF6\u3002",
+  "bad-blueprint": "\u84DD\u56FE\u4E0D\u662F\u5408\u6CD5 JSON \u6216\u683C\u5F0F\u5934\u4E0D\u5BF9\uFF1A\u6309 SKILL \u7684\u5951\u7EA6\u8868\u91CD\u5199\u683C\u5F0F\u5934\u540E\u518D\u8DD1\u4E00\u6B21\u3002",
+  "bad-inventory": "\u9879\u76EE\u6E05\u5355\uFF08project.json\uFF09\u574F\u4E86\uFF1A\u5148\u4FEE\u6E05\u5355\uFF0C\u518D\u5EFA\u623F\u3002",
+  "repo-not-top-level": "\u8BF7\u5728 Git \u4ED3\u5E93\u9876\u5C42\u8FD0\u884C\u8FD9\u4E2A\u547D\u4EE4\uFF08\u5DE5\u4F5C\u533A\u91CC\u4F20\u5DE5\u4F5C\u533A\u6839\u76EE\u5F55\uFF09\u3002",
+  "not-a-git-repo": "\u8FD9\u4E2A\u76EE\u5F55\u4E0D\u662F Git \u4ED3\u5E93\uFF1A\u5EFA\u7B51\u8BCA\u65AD\u8981\u8BFB\u6E05\u5355\u4E0E\u5FEB\u7167\u6807\u7B7E\uFF0C\u9700\u8981 Git \u4ED3\u5E93\u3002",
+  "repo-unavailable": "\u76EE\u5F55\u4E0D\u5B58\u5728\u6216\u8BFB\u4E0D\u4E86\uFF1A\u6838\u5BF9\u4F20\u5165\u7684\u4ED3\u5E93\u6839\u8DEF\u5F84\u3002",
+  "git-unavailable": "\u627E\u4E0D\u5230 git \u53EF\u6267\u884C\u6587\u4EF6\uFF1A\u786E\u8BA4 git \u5DF2\u5B89\u88C5\u5E76\u5728 PATH \u4E2D\u3002"
+};
+async function runBuildingCheck(input) {
+  const repo = { mode: "manual", title: "\u547D\u4EE4\u884C", path: path2.resolve(input), workspaceId: "" };
+  try {
+    await assertRepoUsable(repo.path);
+    await assertRepoTopLevel(repo.path);
+    return { kind: "checked", binding: await readBuildingBinding(repo.path), repo };
+  } catch (error) {
+    if (error instanceof CoreError) return { kind: "failed", code: error.code, error: error.message, repo };
+    return {
+      kind: "failed",
+      code: "internal",
+      error: error instanceof Error ? error.message : String(error),
+      repo
+    };
+  }
+}
+function sorted2(problems) {
+  return [...problems].sort((a, b) => (a.severity === "error" ? 0 : 1) - (b.severity === "error" ? 0 : 1));
+}
+function problemLines(problems) {
+  const lines = [];
+  for (const problem of sorted2(problems)) {
+    const target = FIX_TARGETS[problem.code];
+    lines.push(`[${problem.severity}] ${problem.code} ${problem.subject.path || "(\u6839)"}`);
+    lines.push(`        ${problem.message}`);
+    if (problem.subject.ids.length) lines.push(`        \u6D89\u53CA\uFF1A${problem.subject.ids.join("\u3001")}`);
+    const evidence = Object.entries(problem.evidence ?? {});
+    if (evidence.length) lines.push(`        \u8BC1\u636E\uFF1A${JSON.stringify(Object.fromEntries(evidence))}`);
+    lines.push(`        \u4FEE\u590D\u65B9\u5411\uFF1A${target ? FIX_TARGET_LABELS[target] : "\u672A\u77E5\u95EE\u9898\u7801\uFF1A\u5148\u67E5\u8BCA\u65AD\u76EE\u5F55\uFF0C\u522B\u76F4\u63A5\u6539 JSON"}`);
+    const locate = LOCATE_HINTS[problem.code];
+    if (locate) lines.push(`        \u5B9A\u4F4D\uFF1A${locate}`);
+  }
+  return lines;
+}
+function formatReport(outcome) {
+  if (outcome.kind === "failed") {
+    const lines2 = [
+      `\u5EFA\u7B51\u8BCA\u65AD\uFF1A\u8BFB\u4E0D\u4E86\uFF08${outcome.code}\uFF09`,
+      outcome.error,
+      `\u4ED3\u5E93\uFF1A${outcome.repo?.path ?? "(\u672A\u89E3\u6790)"}`
+    ];
+    const hint = FAILURE_HINTS[outcome.code];
+    if (hint) lines2.push(`\u63D0\u793A\uFF1A${hint}`);
+    return lines2.join("\n");
+  }
+  const { binding, repo } = outcome;
+  const errors = binding.problems.filter((p) => p.severity === "error");
+  const warnings = binding.problems.filter((p) => p.severity === "warning");
+  const entryCount = binding.catalog.businesses.reduce((sum, b) => sum + b.entries.length, 0);
+  const lines = [`\u5EFA\u7B51\u8BCA\u65AD\uFF1A${repo.path}`];
+  if (binding.model) lines.push(`\u9879\u76EE\uFF1A${binding.model.project.name}`);
+  lines.push(
+    `\u84DD\u56FE\uFF1A${binding.blueprintPath}`,
+    `\u6E05\u5355\u4E1A\u52A1 ${binding.catalog.businesses.length} \u4E2A\uFF1B\u623F\u95F4\u7ED1\u5B9A ${binding.rooms.length} \u95F4\uFF1B\u8D44\u6599\u5165\u53E3 ${entryCount} \u6761`
+  );
+  if (binding.rooms.length) {
+    const entriesByBusiness = new Map(binding.catalog.businesses.map((b) => [b.businessId, b.entries.length]));
+    lines.push(`\u623F\u95F4\uFF08${binding.rooms.length}\uFF09`);
+    for (const room of binding.rooms) {
+      const directory = room.directory ? "\u76EE\u5F55\u5F00" : "\u76EE\u5F55\u5173";
+      const count2 = entriesByBusiness.get(room.businessId) ?? 0;
+      lines.push(`  ${room.spaceId} \u2190 ${room.businessId} ${room.businessName}\uFF08${room.floorId}\uFF0C${directory}\uFF0C\u8D44\u6599 ${count2} \u6761\uFF09`);
+    }
+  }
+  lines.push(`\u9519\u8BEF ${errors.length} \u6761\uFF0C\u8B66\u544A ${warnings.length} \u6761`);
+  if (binding.problems.length) lines.push(...problemLines(binding.problems));
+  if (!errors.length) {
+    if (warnings.length) lines.push("\u63D0\u793A\uFF1Awarning \u4E0D\u963B\u585E\u751F\u6210\uFF1B\u4FDD\u7559\u5B83\u4EEC\u65F6\u8981\u5728\u4EA4\u4ED8\u8BF4\u660E\u91CC\u5199\u660E\u7406\u7531\u3002");
+    lines.push("\u7ED3\u8BBA\uFF1A\u901A\u8FC7\uFF08\u6A21\u578B\u53EF\u751F\u6210\uFF09\u3002\u80FD\u5426\u8D70\u901A\u3001\u95E8\u724C\u70B9\u4E0D\u70B9\u5F97\u5F00\uFF0C\u4ECD\u7531\u4F5C\u8005\u5728\u9875\u9762\u9A8C\u6536\u3002");
+    return lines.join("\n");
+  }
+  const count = (target) => errors.filter((p) => FIX_TARGETS[p.code] === target).length;
+  lines.push('\u7ED3\u8BBA\uFF1A\u672A\u901A\u8FC7\uFF08\u6709 error\uFF0C\u6A21\u578B\u4E0D\u4F1A\u751F\u6210\uFF09\u3002\u6309\u6BCF\u6761\u7684"\u4FEE\u590D\u65B9\u5411"\u6539\u5B8C\u518D\u8DD1\u4E00\u6B21\u3002');
+  if (count("blueprint")) lines.push(`  \u6539\u84DD\u56FE ${count("blueprint")} \u6761\uFF1A\u6309 subject.path \u56DE ${binding.blueprintPath} \u6539\u3002`);
+  if (count("inventory")) lines.push(`  \u6539\u6E05\u5355\u6216\u8D44\u6599 ${count("inventory")} \u6761\uFF1A\u6539\u84DD\u56FE\u6539\u4E0D\u597D\u2014\u2014\u62A5\u544A\u4F5C\u8005\uFF0C\u6216\u5148\u4FEE\u6E05\u5355/\u8D44\u6599\u3002`);
+  if (count("evidence")) lines.push(`  \u6309\u8BC1\u636E\u5224 ${count("evidence")} \u6761\uFF1A\u5BF9\u7167 subject.ids \u4E0E\u9879\u76EE\u6E05\u5355\u6838\u5BF9\uFF1B\u9ED8\u8BA4\u5148\u6838\u67E5\u84DD\u56FE\uFF0C\u6E05\u5355\u7684\u53D6\u820D\u4EA4\u4F5C\u8005\u51B3\u5B9A\u3002`);
+  return lines.join("\n");
+}
+function formatJson(outcome) {
+  if (outcome.kind === "failed") {
+    return JSON.stringify({ code: outcome.code, error: outcome.error, repo: outcome.repo }, null, 2);
+  }
+  return JSON.stringify({ ...outcome.binding, repo: outcome.repo }, null, 2);
+}
+function exitCodeOf(outcome) {
+  if (outcome.kind === "failed") return EXIT_UNREADABLE;
+  return outcome.binding.ok ? EXIT_OK : EXIT_PROBLEMS;
+}
+async function main(argv, io) {
+  const jsonCount = argv.filter((arg) => arg === "--json").length;
+  const json = jsonCount > 0;
+  const paths = argv.filter((arg) => arg !== "--json");
+  const unknown = paths.filter((arg) => arg.startsWith("-"));
+  if (unknown.length || paths.length !== 1 || jsonCount > 1) {
+    const message = `${unknown.length ? `\u672A\u77E5\u53C2\u6570\uFF1A${unknown.join("\u3001")}\u3002` : ""}${jsonCount > 1 ? "--json \u53EA\u80FD\u7ED9\u4E00\u6B21\u3002" : ""}${paths.length !== 1 ? "\u9700\u8981\u4E00\u4E2A\u9879\u76EE\u4ED3\u5E93\u6839\u53C2\u6570\u3002" : ""}`;
+    io.err(`${message}
+${USAGE}
+`);
+    if (json) io.out(`${JSON.stringify({ code: "bad-request", error: message, repo: null }, null, 2)}
+`);
+    return EXIT_UNREADABLE;
+  }
+  const outcome = await runBuildingCheck(paths[0]);
+  io.out(json ? `${formatJson(outcome)}
+` : `${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 {
+  EXIT_OK,
+  EXIT_PROBLEMS,
+  EXIT_UNREADABLE,
+  exitCodeOf,
+  formatJson,
+  formatReport,
+  main,
+  runBuildingCheck
+};