@pioneer_zmc/dsh-workbench 0.2.1

package/dist/index.js

@@ -0,0 +1,2873 @@
+// 构建产物：由 scripts/build.mjs 从 src/ 生成，请勿手改。
+
+
+// src/dsh/index.ts
+import { existsSync, readFileSync } from "node:fs";
+import { readFile as readFile2, stat as stat2 } from "node:fs/promises";
+import path2 from "node:path";
+import { fileURLToPath } 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]);
+}
+async function resolveCommit(repoRoot, commit) {
+  if (!isHex40(commit)) {
+    throw new CoreError("bad-request", `\u63D0\u4EA4\u53F7\u5FC5\u987B\u662F 40 \u4F4D\u5341\u516D\u8FDB\u5236\uFF0C\u6536\u5230\uFF1A${commit}`, 400);
+  }
+  let out = null;
+  try {
+    out = await runGit(repoRoot, ["rev-parse", "--verify", `${commit}^{commit}`]);
+  } catch (error) {
+    const confirmedAbsent = error instanceof CoreError && error.code === "git-failed" && ["Needed a single revision", "expected commit type"].some((hint) => error.message.includes(hint));
+    if (!confirmedAbsent) throw error;
+  }
+  const resolved = out?.trim();
+  if (!isHex40(resolved)) {
+    throw new CoreError("not-found", `\u63D0\u4EA4 ${commit} \u65E0\u6CD5\u5728\u672C\u4ED3\u5E93\u89E3\u6790`, 404);
+  }
+  return resolved;
+}
+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/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 };
+}
+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/evidence.ts
+function splitLines(text) {
+  const lines = text.split("\n");
+  if (lines.length > 0 && lines[lines.length - 1] === "") lines.pop();
+  return lines;
+}
+async function resolveEvidenceRefs(repoRoot, refs) {
+  const results = [];
+  for (let i = 0; i < refs.length; i++) {
+    results.push(await resolveOneRef(repoRoot, refs[i], i));
+  }
+  return results;
+}
+async function resolveOneRef(repoRoot, raw, index) {
+  const where = `refs[${index}]`;
+  const base = { id: `refs[${index}]`, label: `\u5F15\u7528 ${index + 1}` };
+  if (typeof raw !== "object" || raw === null || Array.isArray(raw)) {
+    return { ...base, ok: false, error: `${where} \u4E0D\u662F\u5BF9\u8C61` };
+  }
+  const ref = raw;
+  if (typeof ref.id === "string" && ref.id) base.id = ref.id;
+  if (typeof ref.label === "string" && ref.label) base.label = ref.label;
+  const bad = (error) => ({ ...base, ok: false, error: `${where}\uFF08${base.id}\uFF09\uFF1A${error}` });
+  if (ref.repo !== void 0 && ref.repo !== ".") return bad('\u7B2C\u4E00\u6279\u53EA\u652F\u6301\u540C\u4ED3\u5F15\u7528\uFF08repo \u5FC5\u987B\u662F "."\uFF09');
+  if (typeof ref.commit !== "string" || !/^[0-9a-f]{40}$/.test(ref.commit)) {
+    return bad("commit \u5FC5\u987B\u662F 40 \u4F4D\u5341\u516D\u8FDB\u5236\u63D0\u4EA4\u53F7");
+  }
+  if (typeof ref.path !== "string" || !ref.path || pathIsUnsafe(ref.path)) {
+    return bad("path \u5FC5\u987B\u662F\u4ED3\u5E93\u5185\u7684\u76F8\u5BF9\u8DEF\u5F84");
+  }
+  const fromLine = ref.fromLine;
+  const toLine = ref.toLine;
+  if (typeof fromLine !== "number" || typeof toLine !== "number" || !Number.isInteger(fromLine) || !Number.isInteger(toLine)) {
+    return bad("fromLine / toLine \u5FC5\u987B\u662F\u6574\u6570");
+  }
+  try {
+    await resolveCommit(repoRoot, ref.commit);
+  } catch (error) {
+    if (!(error instanceof CoreError) || error.code !== "not-found") throw error;
+    return bad(`\u63D0\u4EA4 ${ref.commit.slice(0, 8)} \u65E0\u6CD5\u5728\u672C\u4ED3\u5E93\u89E3\u6790`);
+  }
+  let text;
+  try {
+    text = await gitShowFileOptional(repoRoot, ref.commit, ref.path);
+  } catch (error) {
+    return bad(error.message);
+  }
+  if (text === null) return bad(`\u6587\u4EF6 ${ref.path} \u5728\u63D0\u4EA4 ${ref.commit.slice(0, 8)} \u4E0A\u4E0D\u5B58\u5728`);
+  const lines = splitLines(text);
+  if (fromLine < 1 || fromLine > toLine || toLine > lines.length) {
+    return bad(`\u884C\u8303\u56F4\u8D8A\u754C\uFF1A\u8BE5\u63D0\u4EA4\u4E0A\u6587\u4EF6\u5171 ${lines.length} \u884C\uFF0C\u5F15\u7528 ${fromLine}\u2013${toLine} \u884C`);
+  }
+  return {
+    ...base,
+    ok: true,
+    repo: ".",
+    commit: ref.commit,
+    path: ref.path,
+    fromLine,
+    toLine,
+    lineCount: lines.length,
+    text: lines.slice(fromLine - 1, toLine).join("\n")
+  };
+}
+function pathIsUnsafe(p) {
+  if (p.includes("\\") || /^[a-zA-Z]:/.test(p) || p.startsWith("/")) return true;
+  const parts = p.split("/");
+  return parts.some((part) => part === "" || part === "." || part === "..");
+}
+async function loadEvidence(repoRoot, evidenceText) {
+  if (evidenceText === null) return { missing: true, refs: [] };
+  let parsed;
+  try {
+    parsed = JSON.parse(evidenceText);
+  } catch (error) {
+    return { missing: false, parseError: `evidence.json \u4E0D\u662F\u5408\u6CD5 JSON\uFF1A${error.message}`, refs: [] };
+  }
+  if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+    return { missing: false, parseError: "evidence.json \u9876\u5C42\u5FC5\u987B\u662F\u5BF9\u8C61", refs: [] };
+  }
+  const refs = parsed.refs;
+  if (refs === void 0) {
+    return { missing: false, parseError: "evidence.json \u7F3A\u5C11 refs \u5B57\u6BB5", refs: [] };
+  }
+  if (!Array.isArray(refs)) {
+    return { missing: false, parseError: "refs \u5FC5\u987B\u662F\u6570\u7EC4", refs: [] };
+  }
+  return { missing: false, refs: await resolveEvidenceRefs(repoRoot, refs) };
+}
+
+// src/core/inventory.ts
+import { readdir as readdir2 } from "node:fs/promises";
+
+// 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((name2) => {
+      const text = files[FILE_KEY[name2]];
+      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 name2 of CHART_FILE_NAMES) {
+    const worktree = await readWorktreeFileOptional(repoRoot, `${chartDir}/${name2}`);
+    const snapshot = await gitShowFileOptional(repoRoot, latest.commit, `${latest.meta.dir}/${name2}`);
+    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 name2 of CHART_FILE_NAMES) {
+    const key = FILE_KEYS[name2];
+    try {
+      files[key] = await readWorktreeFileOptional(repoRoot, `${chartDir}/${name2}`);
+    } 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 name2 of CHART_FILE_NAMES) {
+    const key = FILE_KEYS[name2];
+    try {
+      files[key] = await gitShowFileOptional(repoRoot, snapshot.commit, `${dir}/${name2}`);
+    } 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/core/save.ts
+async function resolveHeadOptional(repoRoot) {
+  try {
+    return (await runGit(repoRoot, ["rev-parse", "HEAD"])).trim();
+  } catch (error) {
+    const unborn = error instanceof CoreError && error.code === "git-failed" && error.message.includes("unknown revision");
+    if (unborn) return null;
+    throw error;
+  }
+}
+async function readTriFiles(read) {
+  const files = { workflow: null, details: null, evidence: null };
+  const errors = {};
+  for (const name2 of CHART_FILE_NAMES) {
+    const key = FILE_KEY[name2];
+    try {
+      files[key] = await read(name2);
+    } catch (error) {
+      errors[key] = error instanceof Error ? error.message : String(error);
+    }
+  }
+  return { files, errors };
+}
+async function collectSaveCheck(repoRoot, chartDir, head) {
+  const worktree = await readTriFiles((name2) => readWorktreeFileOptional(repoRoot, `${chartDir}/${name2}`));
+  const committed = await readTriFiles((name2) => gitShowFileOptional(repoRoot, head, `${chartDir}/${name2}`));
+  const problems = [];
+  if (worktree.files.workflow === null && !worktree.errors.workflow) {
+    problems.push("\u56FE\u8FD8\u4E0D\u5B58\u5728\uFF1Aworkflow.json \u7F3A\u5931\uFF0C\u6CA1\u6709\u53EF\u4FDD\u5B58\u7684\u5185\u5BB9");
+  }
+  for (const name2 of CHART_FILE_NAMES) {
+    const key = FILE_KEY[name2];
+    if (worktree.errors[key]) {
+      problems.push(`${name2} \u8BFB\u4E0D\u5F00\uFF08${worktree.errors[key]}\uFF09`);
+      continue;
+    }
+    if (committed.errors[key]) {
+      problems.push(`${name2} \u5728\u6700\u8FD1\u4E00\u6B21\u63D0\u4EA4\u4E0A\u8BFB\u4E0D\u5F00\uFF08${committed.errors[key]}\uFF09`);
+      continue;
+    }
+    if (key === "workflow" && worktree.files.workflow === null) continue;
+    const w = worktree.files[key];
+    const h = committed.files[key];
+    if (h === null && w !== null) problems.push(`${name2} \u8FD8\u6CA1\u6709\u63D0\u4EA4\u8FC7\uFF08\u65B0\u6587\u4EF6\uFF09`);
+    else if (h !== null && w === null) problems.push(`${name2} \u5728\u5DE5\u4F5C\u533A\u88AB\u5220\u9664\uFF0C\u5220\u9664\u5C1A\u672A\u63D0\u4EA4`);
+    else if (h !== null && w !== null && normalizeEol(w) !== normalizeEol(h)) problems.push(`${name2} \u6709\u672A\u63D0\u4EA4\u7684\u4FEE\u6539`);
+  }
+  const fingerprint = committed.errors.workflow || committed.errors.details || committed.errors.evidence ? null : fingerprintOf(committed.files);
+  return { problems, fingerprint, headFiles: committed.files };
+}
+async function chartBlobIds(repoRoot, commit, chartDir) {
+  const out = await runGit(repoRoot, ["ls-tree", commit, "--", ...CHART_FILE_NAMES.map((n) => `${chartDir}/${n}`)]);
+  const blobs = { workflow: null, details: null, evidence: null };
+  for (const line of out.split("\n")) {
+    const tab = line.indexOf("	");
+    if (tab < 0) continue;
+    const fields = line.slice(0, tab).split(" ");
+    const fileName = line.slice(tab + 1).trim().split("/").pop();
+    if (!(fileName in FILE_KEY) || fields[1] !== "blob") continue;
+    blobs[FILE_KEY[fileName]] = fields[2];
+  }
+  return blobs;
+}
+async function findDuplicateSnapshot(repoRoot, records, chartId, stage, headIds) {
+  for (const snapshot of snapshotsForChart(records, chartId).snapshots) {
+    if (snapshot.meta.stage !== stage) continue;
+    const snapIds = await chartBlobIds(repoRoot, snapshot.commit, snapshot.meta.dir);
+    if (CHART_FILE_NAMES.every((n) => headIds[FILE_KEY[n]] === snapIds[FILE_KEY[n]])) return snapshot;
+  }
+  return null;
+}
+function pickTagName(records, base) {
+  const taken = new Set(records.map((r) => r.tag));
+  let tag = base;
+  let suffix = 2;
+  while (taken.has(tag)) {
+    if (suffix > MAX_NAME_SUFFIX) {
+      throw new CoreError("tag-name-exhausted", `\u6807\u7B7E\u540D ${base} \u5DF2\u88AB\u5360\u7528\uFF0C\u4E14\u627E\u4E0D\u5230\u53EF\u7528\u53D8\u4F53`, 500);
+    }
+    tag = `${base}-${suffix}`;
+    suffix += 1;
+  }
+  return tag;
+}
+async function checkChartCommitted(repoRoot, businessId, chartId) {
+  const chartDir = await locateChartDir(repoRoot, businessId, chartId);
+  const head = await resolveHeadOptional(repoRoot);
+  if (head === null) {
+    return { head: null, ok: false, problems: ["\u8FD9\u4E2A\u4ED3\u5E93\u8FD8\u6CA1\u6709\u4EFB\u4F55\u63D0\u4EA4\uFF0C\u6CA1\u6709\u53EF\u4FDD\u5B58\u7684\u5185\u5BB9"], fingerprint: null };
+  }
+  const { problems, fingerprint } = await collectSaveCheck(repoRoot, chartDir, head);
+  return { head, ok: problems.length === 0, problems, fingerprint };
+}
+var NAME_MAX = 200;
+var NOTE_MAX = 1e3;
+var MAX_TAG_ATTEMPTS = 5;
+var MAX_NAME_SUFFIX = 50;
+var saveQueues = /* @__PURE__ */ new Map();
+function withChartLock(key, task) {
+  const previous = saveQueues.get(key) ?? Promise.resolve();
+  const run = previous.then(task, task);
+  const tail = run.then(() => void 0, () => void 0);
+  saveQueues.set(key, tail);
+  void tail.then(() => {
+    if (saveQueues.get(key) === tail) saveQueues.delete(key);
+  });
+  return run;
+}
+function createdUnverifiedError(tag, error) {
+  if (error instanceof CoreError && error.code === "save-created-unverified") return error;
+  const reason = error instanceof Error ? error.message : String(error);
+  return new CoreError(
+    "save-created-unverified",
+    `\u7248\u672C ${tag} \u5DF2\u7ECF\u5199\u4E0A\u53BB\u4E86\uFF0C\u4F46\u8BFB\u56DE\u6838\u5BF9\u6CA1\u505A\u5B8C\uFF1A${reason}\u3002\u8BF7\u5237\u65B0\u9875\u9762\u770B\u7248\u672C\u5217\u8868\u786E\u8BA4\u3002`,
+    500
+  );
+}
+function validateInput(raw) {
+  if (typeof raw !== "object" || raw === null || Array.isArray(raw)) {
+    throw new CoreError("bad-request", "\u4FDD\u5B58\u4FE1\u606F\u4E0D\u5408\u6CD5\uFF08\u5FC5\u987B\u662F\u5BF9\u8C61\uFF09", 400);
+  }
+  const m = raw;
+  const name2 = typeof m.name === "string" ? m.name.trim() : "";
+  if (name2.length < 1 || name2.length > NAME_MAX) {
+    throw new CoreError("bad-request", `\u7248\u672C\u540D\u79F0\u5FC5\u586B\uFF0C\u4E14\u4E0D\u8D85\u8FC7 ${NAME_MAX} \u4E2A\u5B57`, 400);
+  }
+  const stage = m.stage === "design" || m.stage === "implemented" ? m.stage : null;
+  if (stage === null) {
+    throw new CoreError("bad-request", "\u9636\u6BB5\u5FC5\u987B\u662F design\uFF08\u8BBE\u8BA1\u7248\uFF09\u6216 implemented\uFF08\u5B9E\u73B0\u7248\uFF09", 400);
+  }
+  if (m.note !== void 0 && m.note !== null && typeof m.note !== "string") {
+    throw new CoreError("bad-request", "\u4FDD\u5B58\u8BF4\u660E\u4E0D\u5408\u6CD5\uFF08\u5FC5\u987B\u662F\u6587\u672C\uFF09", 400);
+  }
+  let note;
+  if (typeof m.note === "string" && m.note.trim()) {
+    note = m.note.trim();
+    if (note.length > NOTE_MAX) {
+      throw new CoreError("bad-request", `\u4FDD\u5B58\u8BF4\u660E\u4E0D\u8D85\u8FC7 ${NOTE_MAX} \u4E2A\u5B57`, 400);
+    }
+  }
+  return { name: name2, stage, note };
+}
+var pad2 = (n) => String(n).padStart(2, "0");
+function localIso(d) {
+  const offsetMin = -d.getTimezoneOffset();
+  const sign = offsetMin >= 0 ? "+" : "-";
+  const abs = Math.abs(offsetMin);
+  return `${d.getFullYear()}-${pad2(d.getMonth() + 1)}-${pad2(d.getDate())}T${pad2(d.getHours())}:${pad2(d.getMinutes())}:${pad2(d.getSeconds())}${sign}${pad2(Math.floor(abs / 60))}:${pad2(abs % 60)}`;
+}
+function localStamp(d) {
+  return `${d.getFullYear()}${pad2(d.getMonth() + 1)}${pad2(d.getDate())}-${pad2(d.getHours())}${pad2(d.getMinutes())}${pad2(d.getSeconds())}`;
+}
+async function saveChartSnapshot(repoRoot, businessId, chartId, input, options) {
+  const { name: name2, stage, note } = validateInput(input);
+  if (!/^[0-9a-f]{40}$/.test(options.expectedHead)) {
+    throw new CoreError("bad-request", `\u786E\u8BA4\u8FC7\u7684\u63D0\u4EA4\u53F7\u4E0D\u5408\u6CD5\uFF1A${options.expectedHead}`, 400);
+  }
+  const chartDir = await locateChartDir(repoRoot, businessId, chartId);
+  return withChartLock(
+    `${repoRoot}\0${chartId}`,
+    () => createSnapshot(repoRoot, chartDir, chartId, { name: name2, stage, note }, options)
+  );
+}
+async function createSnapshot(repoRoot, chartDir, chartId, meta, options) {
+  const { name: name2, stage, note } = meta;
+  const head = await resolveHeadOptional(repoRoot);
+  if (head === null) {
+    throw new CoreError("uncommitted-changes", "\u8FD9\u4E2A\u4ED3\u5E93\u8FD8\u6CA1\u6709\u4EFB\u4F55\u63D0\u4EA4\uFF0C\u6CA1\u6709\u53EF\u4FDD\u5B58\u7684\u5185\u5BB9", 409);
+  }
+  const check = await collectSaveCheck(repoRoot, chartDir, head);
+  if (check.problems.length > 0) {
+    throw new CoreError(
+      "uncommitted-changes",
+      `\u5F53\u524D\u56FE\u8FD8\u6709\u672A\u63D0\u4EA4\u7684\u4FEE\u6539\uFF0C\u8BF7\u5148\u63D0\u4EA4\uFF0C\u518D\u4FDD\u5B58\u7248\u672C\uFF1A
+- ${check.problems.join("\n- ")}`,
+      409
+    );
+  }
+  if (head !== options.expectedHead) {
+    throw new CoreError("content-updated", "\u5185\u5BB9\u5DF2\u66F4\u65B0\uFF0C\u8BF7\u5237\u65B0\u540E\u786E\u8BA4\uFF08\u540E\u53F0\u6709\u4E86\u65B0\u7684\u63D0\u4EA4\uFF09", 409);
+  }
+  if (options.fingerprint !== check.fingerprint) {
+    throw new CoreError("content-updated", "\u5185\u5BB9\u5DF2\u66F4\u65B0\uFF0C\u8BF7\u5237\u65B0\u540E\u786E\u8BA4\uFF08\u9875\u9762\u5C55\u793A\u7684\u5185\u5BB9\u4E0E\u5C06\u8981\u4FDD\u5B58\u7684\u4E0D\u4E00\u81F4\uFF09", 409);
+  }
+  const headIds = await chartBlobIds(repoRoot, head, chartDir);
+  const now = options.now ?? /* @__PURE__ */ new Date();
+  const base = `specdev/${chartId}/${localStamp(now)}`;
+  const savedAt = localIso(now);
+  const message = JSON.stringify({
+    schema: SCHEMA.snapshot,
+    chart: chartId,
+    name: name2,
+    stage,
+    ...note !== void 0 ? { note } : {},
+    dir: chartDir,
+    savedAt
+  });
+  let created = null;
+  for (let attempt = 0; attempt < MAX_TAG_ATTEMPTS && created === null; attempt += 1) {
+    const records = await listSpecdevTags(repoRoot);
+    const duplicate = await findDuplicateSnapshot(repoRoot, records, chartId, stage, headIds);
+    if (duplicate) return { snapshot: duplicate, alreadySaved: true };
+    const tag = pickTagName(records, base);
+    try {
+      await runGit(repoRoot, ["tag", "-a", tag, "-m", message, head]);
+      created = tag;
+    } catch (error) {
+      const latest = await listSpecdevTags(repoRoot);
+      const contention = latest.some((r) => r.tag === tag) || await findDuplicateSnapshot(repoRoot, latest, chartId, stage, headIds) !== null;
+      if (!contention) throw error;
+    }
+  }
+  if (created === null) {
+    throw new CoreError(
+      "save-conflict",
+      `\u8FDE\u7EED ${MAX_TAG_ATTEMPTS} \u6B21\u90FD\u6CA1\u80FD\u5360\u7528\u7248\u672C\u540D\uFF08\u540C\u540D\u6807\u7B7E\u4E00\u76F4\u88AB\u62A2\u5148\uFF09\uFF0C\u8BF7\u7A0D\u540E\u91CD\u8BD5`,
+      409
+    );
+  }
+  try {
+    const entry = findSnapshot(await listSpecdevTags(repoRoot), created);
+    const expected = { schema: SCHEMA.snapshot, chart: chartId, name: name2, stage, note, dir: chartDir, savedAt };
+    const mismatch = Object.keys(expected).filter((k) => entry.meta[k] !== expected[k]);
+    if (entry.commit !== head || mismatch.length > 0) {
+      throw new CoreError(
+        "save-created-unverified",
+        `\u7248\u672C ${created} \u5DF2\u7ECF\u5199\u4E0A\u53BB\u4E86\uFF0C\u4F46\u8BFB\u56DE\u6838\u5BF9\u4E0D\u4E00\u81F4\uFF08${["commit", ...mismatch].join("\u3001")}\uFF09\u3002\u8BF7\u5237\u65B0\u9875\u9762\u770B\u7248\u672C\u5217\u8868\u786E\u8BA4\u3002`,
+        500
+      );
+    }
+    for (const n of CHART_FILE_NAMES) {
+      const back = await gitShowFileOptional(repoRoot, entry.commit, `${chartDir}/${n}`);
+      if (back !== check.headFiles[FILE_KEY[n]]) {
+        throw new CoreError(
+          "save-created-unverified",
+          `\u7248\u672C ${created} \u5DF2\u7ECF\u5199\u4E0A\u53BB\u4E86\uFF0C\u4F46 ${n} \u7684\u8BFB\u56DE\u5185\u5BB9\u4E0E\u5C06\u8981\u4FDD\u5B58\u7684\u4E0D\u4E00\u81F4\u3002\u8BF7\u5237\u65B0\u9875\u9762\u770B\u7248\u672C\u5217\u8868\u786E\u8BA4\u3002`,
+          500
+        );
+      }
+    }
+    return { snapshot: entry, alreadySaved: false };
+  } catch (error) {
+    throw createdUnverifiedError(created, error);
+  }
+}
+
+// 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 name2 = s.kind === "room" ? source?.name ?? s.name ?? s.businessId ?? s.id : s.name ?? s.id;
+    return {
+      ...s,
+      name: name2,
+      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 };
+}
+function presentBuilding(model, { preview = false } = {}) {
+  const parts = [];
+  const colliders = [];
+  const surfaces = [];
+  const phase = PHASES.indexOf(model.construction.phase);
+  const timber = model.style === "chinese-timber";
+  const palette = timber ? { frame: "#74503b", slab: "#b2a18b", wall: "#dfd6c4", roof: "#4b5550" } : { frame: "#a88059", slab: "#d8c9b5", wall: "#ece1cd", roof: "#69756f" };
+  const roomMap = new Map(model.rooms.map((r) => [r.id, r]));
+  const groundY = Math.min(...model.spaces.map((s) => s.y));
+  const part = (id, kind, position, size, color, { opacity = 1, solid = false, rotation, spaceIds = [] } = {}) => {
+    if (Math.min(size.x, size.y, size.z) <= 0) return;
+    const value = { id, kind, position, size, color, opacity, solid, spaceIds };
+    if (rotation) value.rotation = rotation;
+    parts.push(value);
+    if (solid && !rotation) {
+      colliders.push({
+        id,
+        x0: position.x - size.x / 2,
+        x1: position.x + size.x / 2,
+        y0: position.y - size.y / 2,
+        y1: position.y + size.y / 2,
+        z0: position.z - size.z / 2,
+        z1: position.z + size.z / 2
+      });
+    }
+  };
+  for (const space of model.spaces) {
+    const { rect, y, bounds } = space;
+    const builtFloor = preview || phase >= 2 || phase === 1 && eq(y, groundY);
+    const depth = builtFloor ? model.defaults.slabThickness : 0.035;
+    const kind = !builtFloor ? "plan-floor" : phase === 1 && !preview ? "foundation" : "floor";
+    part(
+      `floor:${space.id}`,
+      kind,
+      { x: rect.x, y: y - depth / 2, z: rect.z },
+      { x: rect.width, y: depth, z: rect.depth },
+      space.kind === "room" ? space.accent : palette.slab,
+      { opacity: builtFloor ? 1 : 0.35, spaceIds: [space.id] }
+    );
+    surfaces.push({ id: space.id, kind: "flat", bounds, y, spaceId: space.id });
+  }
+  const jointFrameKeys = /* @__PURE__ */ new Set();
+  for (const joint of model.floorJoints) {
+    const b = joint.bounds;
+    const spaceIds = [joint.upperSpaceId];
+    if (preview || phase >= 2) {
+      part(
+        joint.id,
+        "floor-joint",
+        { x: (b.x0 + b.x1) / 2, y: (joint.y0 + joint.y1) / 2, z: (b.z0 + b.z1) / 2 },
+        { x: b.x1 - b.x0, y: joint.y1 - joint.y0, z: b.z1 - b.z0 },
+        palette.slab,
+        { solid: true, spaceIds }
+      );
+    } else {
+      for (const x of [b.x0, b.x1]) {
+        for (const z of [b.z0, b.z1]) {
+          const key = `${x}:${z}:${joint.y0}:${joint.upperY}`;
+          if (jointFrameKeys.has(key)) continue;
+          jointFrameKeys.add(key);
+          part(
+            `joint-frame:${key}`,
+            "floor-joint-frame",
+            { x, y: (joint.y0 + joint.upperY) / 2, z },
+            { x: 0.045, y: joint.upperY - joint.y0, z: 0.045 },
+            palette.frame,
+            { opacity: 0.55, spaceIds }
+          );
+        }
+      }
+    }
+  }
+  const frameKeys = /* @__PURE__ */ new Set();
+  for (const wall of model.walls) {
+    const owners = wall.spaceIds.map((id) => roomMap.get(id));
+    const implemented = owners.every((r) => r?.status.implementation === "present");
+    const complete = owners.every((r) => r?.status.tests === "passed" && r?.status.acceptance === "passed");
+    const showSkin = preview || phase >= 3;
+    if (showSkin) {
+      for (const segment of wall.segments) {
+        const color = preview || implemented && complete ? wall.wallType === "brick" ? "#938777" : wall.wallType === "timber" ? "#a08060" : palette.wall : implemented ? "#e4b84e" : "#a1c9d0";
+        part(segment.id, "wall", segment.position, segment.size, color, {
+          opacity: preview || implemented ? 1 : 0.22,
+          solid: preview || implemented,
+          spaceIds: wall.spaceIds
+        });
+      }
+    }
+    const width = phase >= 2 || preview ? 0.14 : 0.055;
+    for (const at of [wall.lo, wall.hi]) {
+      const x = wall.axis === "x" ? at : wall.at;
+      const z = wall.axis === "z" ? at : wall.at;
+      const key = `${wall.floorId}:${x}:${z}:${wall.height}`;
+      if (frameKeys.has(key)) continue;
+      frameKeys.add(key);
+      part(
+        `post:${key}`,
+        "frame",
+        { x, y: wall.y + wall.height / 2, z },
+        { x: width, y: wall.height, z: width },
+        palette.frame,
+        { opacity: phase === 0 && !preview ? 0.65 : 1, spaceIds: wall.spaceIds }
+      );
+    }
+    const beam = planeBox(wall.axis, wall.at, wall.lo, wall.hi, wall.y + wall.height - width, wall.y + wall.height, width);
+    part(`beam:${wall.id}`, "frame", beam.position, beam.size, palette.frame, { spaceIds: wall.spaceIds });
+    for (const o of wall.openings) {
+      for (const at of [o.lo, o.hi]) {
+        const jamb = planeBox(wall.axis, wall.at, at - 0.045, at + 0.045, wall.y + o.sill, wall.y + o.sill + o.height, model.defaults.wallThickness + 0.045);
+        part(`jamb:${o.id}:${at}`, "opening-frame", jamb.position, jamb.size, palette.frame, {
+          opacity: preview || phase >= 2 ? 1 : 0.35,
+          spaceIds: wall.spaceIds
+        });
+      }
+      const lintel = planeBox(wall.axis, wall.at, o.lo, o.hi, wall.y + o.sill + o.height, wall.y + o.sill + o.height + 0.07, model.defaults.wallThickness + 0.045);
+      part(`lintel:${o.id}`, "opening-frame", lintel.position, lintel.size, palette.frame, {
+        opacity: preview || phase >= 2 ? 1 : 0.35,
+        spaceIds: wall.spaceIds
+      });
+      if (o.kind === "window" && showSkin) {
+        const glass = planeBox(wall.axis, wall.at, o.lo, o.hi, wall.y + o.sill, wall.y + o.sill + o.height, 0.035);
+        part(`glass:${o.id}`, "glass", glass.position, glass.size, "#afcbd0", {
+          opacity: 0.28,
+          solid: preview || implemented,
+          spaceIds: wall.spaceIds
+        });
+      }
+    }
+  }
+  for (const stair of model.stairs) {
+    surfaces.push({
+      id: stair.id,
+      kind: "stair",
+      bounds: stair.bounds,
+      from: stair.from,
+      to: stair.to,
+      ux: stair.ux,
+      uz: stair.uz,
+      length: stair.length,
+      rise: stair.rise,
+      width: stair.width
+    });
+    for (let i = 0; i < stair.steps; i++) {
+      const t = (i + 0.5) / stair.steps;
+      const h = (i + 1) / stair.steps * stair.rise;
+      part(
+        `step:${stair.id}:${i}`,
+        "stair",
+        { x: stair.from.x + stair.ux * stair.length * t, y: stair.from.y + h - 0.065, z: stair.from.z + stair.uz * stair.length * t },
+        {
+          x: Math.abs(stair.ux) > 0.5 ? stair.length / stair.steps : stair.width,
+          y: 0.13,
+          z: Math.abs(stair.uz) > 0.5 ? stair.length / stair.steps : stair.width
+        },
+        palette.frame,
+        { opacity: preview || phase >= 2 ? 1 : 0.28, spaceIds: [stair.from.spaceId, stair.to.spaceId] }
+      );
+    }
+  }
+  for (const roof of model.roofs) {
+    const b = roof.bounds;
+    const width = b.x1 - b.x0;
+    const depth = b.z1 - b.z0;
+    const x = (b.x0 + b.x1) / 2;
+    const z = (b.z0 + b.z1) / 2;
+    if (preview || phase >= 3) {
+      if (roof.type === "flat") {
+        part(`roof:${roof.id}`, "roof", { x, y: roof.base + 0.09, z }, { x: width, y: 0.18, z: depth }, palette.roof, {
+          spaceIds: roof.spaceIds
+        });
+      } else {
+        for (const sign of [-1, 1]) {
+          part(
+            `roof:${roof.id}:${sign}`,
+            "roof",
+            { x, y: roof.base + roof.rise / 2, z: z + sign * depth / 4 },
+            { x: width, y: 0.16, z: Math.hypot(depth / 2, roof.rise) },
+            palette.roof,
+            { rotation: { x: sign * Math.atan2(roof.rise, depth / 2), y: 0, z: 0 }, spaceIds: roof.spaceIds }
+          );
+        }
+      }
+    } else {
+      if (roof.type === "gable") {
+        part(`ridge:${roof.id}`, "roof-frame", { x, y: roof.base + roof.rise, z }, { x: width, y: 0.045, z: 0.045 }, palette.frame, {
+          opacity: 0.55,
+          spaceIds: roof.spaceIds
+        });
+        for (const end of [b.x0, b.x1]) {
+          for (const sign of [-1, 1]) {
+            part(
+              `rafter:${roof.id}:${end}:${sign}`,
+              "roof-frame",
+              { x: end, y: roof.base + roof.rise / 2, z: z + sign * depth / 4 },
+              { x: 0.045, y: 0.045, z: Math.hypot(depth / 2, roof.rise) },
+              palette.frame,
+              { rotation: { x: sign * Math.atan2(roof.rise, depth / 2), y: 0, z: 0 }, opacity: 0.55, spaceIds: roof.spaceIds }
+            );
+          }
+        }
+      }
+    }
+  }
+  return { parts, colliders, surfaces };
+}
+
+// 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/dsh/index.ts
+var name = "specdev-workbench";
+var inject = ["webServer", "connection", "skills", "fs"];
+function findPackageRoot() {
+  let dir = path2.dirname(fileURLToPath(import.meta.url));
+  while (true) {
+    if (existsSync(path2.join(dir, "package.json"))) return dir;
+    const parent = path2.dirname(dir);
+    if (parent === dir) throw new Error("\u627E\u4E0D\u5230\u5305\u6839\uFF08package.json\uFF09");
+    dir = parent;
+  }
+}
+var MIME = {
+  ".html": "text/html; charset=utf-8",
+  ".js": "text/javascript; charset=utf-8",
+  ".mjs": "text/javascript; charset=utf-8",
+  ".css": "text/css; charset=utf-8",
+  ".json": "application/json; charset=utf-8",
+  ".md": "text/markdown; charset=utf-8",
+  ".svg": "image/svg+xml",
+  ".webp": "image/webp",
+  ".txt": "text/plain; charset=utf-8"
+};
+function sendJson(res, status, body) {
+  const text = JSON.stringify(body);
+  res.writeHead(status, {
+    "Content-Type": "application/json; charset=utf-8",
+    "Cache-Control": "no-store",
+    "Content-Length": Buffer.byteLength(text)
+  });
+  res.end(text);
+}
+function sendError(res, error) {
+  if (error instanceof CoreError) {
+    sendJson(res, error.httpStatus, { code: error.code, error: error.message });
+    return;
+  }
+  sendJson(res, 500, { code: "internal", error: error instanceof Error ? error.message : String(error) });
+}
+var BODY_TIMEOUT_MS = 1e4;
+async function readRequestText(req, res) {
+  return await new Promise((resolve) => {
+    const chunks = [];
+    let received = 0;
+    let settled = false;
+    const finish = (value) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      chunks.length = 0;
+      req.off("data", onData);
+      req.off("end", onEnd);
+      req.off("aborted", onAborted);
+      res.off("close", onResponseClose);
+      resolve(value);
+    };
+    const rejectBody = (error) => {
+      if (settled) return;
+      finish(null);
+      req.pause();
+      const disconnect = () => {
+        clearTimeout(closeTimer);
+        res.off("finish", disconnect);
+        res.off("close", disconnect);
+        req.destroy();
+      };
+      const closeTimer = setTimeout(disconnect, 1e3);
+      closeTimer.unref?.();
+      res.once("finish", disconnect);
+      res.once("close", disconnect);
+      if (!res.headersSent && !res.destroyed) {
+        res.setHeader("Connection", "close");
+        sendError(res, error);
+      } else {
+        disconnect();
+      }
+    };
+    const onData = (chunk) => {
+      received += chunk.length;
+      if (received > MAX_FILE_BYTES) {
+        rejectBody(new CoreError("request-too-large", `\u8BF7\u6C42\u6B63\u6587\u8D85\u8FC7\u8BFB\u53D6\u4E0A\u9650 ${MAX_FILE_BYTES} \u5B57\u8282\uFF0C\u5DF2\u505C\u6B62\u63A5\u6536`, 413));
+        return;
+      }
+      chunks.push(chunk);
+    };
+    const onEnd = () => finish(Buffer.concat(chunks).toString("utf8"));
+    const onAborted = () => finish(null);
+    const onError = () => finish(null);
+    const onResponseClose = () => {
+      finish(null);
+      if (!req.complete) req.destroy();
+    };
+    const onRequestClose = () => {
+      finish(null);
+      req.off("error", onError);
+    };
+    const timer = setTimeout(() => rejectBody(new CoreError(
+      "request-timeout",
+      `\u8BF7\u6C42\u6B63\u6587\u8D85\u8FC7 ${BODY_TIMEOUT_MS / 1e3} \u79D2\u6CA1\u6709\u6536\u5B8C\uFF0C\u5DF2\u65AD\u5F00`,
+      408
+    )), BODY_TIMEOUT_MS);
+    timer.unref?.();
+    req.on("data", onData);
+    req.once("end", onEnd);
+    req.once("aborted", onAborted);
+    req.on("error", onError);
+    req.once("close", onRequestClose);
+    res.once("close", onResponseClose);
+  });
+}
+function repoNotConfigured(res) {
+  sendJson(res, 400, {
+    code: "repo-not-configured",
+    error: "\u5C1A\u672A\u914D\u7F6E\u4E1A\u52A1\u9879\u76EE\u76EE\u5F55\uFF08repoRoot\uFF09\u3002\u63D2\u4EF6\u672C\u8EAB\u5DF2\u6B63\u5E38\u52A0\u8F7D\uFF1B\u8BF7\u6309\u4E0B\u9762\u7684\u793A\u4F8B\u5728 profile \u914D\u7F6E\u91CC\u6307\u5B9A\u540E\u91CD\u542F DSH\u3002",
+    guide: {
+      where: "$DSH_HOME/profiles/<profile\u540D>/cordis.patch.yml\uFF08profile \u81EA\u5DF1\u7684\u914D\u7F6E\u5C42\uFF0C\u6309 id \u8986\u76D6\u672C\u63D2\u4EF6\u7684\u884C\uFF09",
+      // 勿写 - insert：insert 是新增条目，会与本包自带条目撞 id（duplicate loader entry）启动失败；
+      // 同 id 不带 insert 才是覆盖。
+      example: [
+        "- id: specdev-workbench",
+        "  config:",
+        "    repoRoot: 'D:/\u4F60\u7684/\u4E1A\u52A1\u9879\u76EE\u4ED3\u5E93'"
+      ].join("\n"),
+      takesEffect: "\u4FDD\u5B58\u914D\u7F6E\u540E\u91CD\u542F DSH \u751F\u6548\uFF08\u914D\u7F6E\u5728\u542F\u52A8\u65F6\u7EC4\u5408\uFF0C\u6539\u914D\u7F6E\u6587\u4EF6\u4E0D\u4F1A\u70ED\u751F\u6548\uFF09\u3002"
+    }
+  });
+}
+async function serveFile(res, base, rel) {
+  const parts = rel.split("/").filter((p) => p !== "" && p !== ".");
+  if (parts.length === 0 || parts.some((p) => p === "..")) return false;
+  const full = path2.resolve(base, ...parts);
+  const root = path2.resolve(base);
+  if (!full.startsWith(root + path2.sep)) return false;
+  let size;
+  try {
+    size = (await stat2(full)).size;
+  } catch {
+    return false;
+  }
+  if (size > MAX_FILE_BYTES) {
+    sendError(res, new CoreError("file-too-large", `\u9759\u6001\u8D44\u6E90 ${rel} \u4E3A ${size} \u5B57\u8282\uFF0C\u8D85\u8FC7\u8BFB\u53D6\u4E0A\u9650 ${MAX_FILE_BYTES} \u5B57\u8282`, 413));
+    return true;
+  }
+  const body = await readFile2(full);
+  res.writeHead(200, {
+    "Content-Type": MIME[path2.extname(full).toLowerCase()] ?? "application/octet-stream",
+    "Cache-Control": "no-store",
+    "Content-Length": body.length
+  });
+  res.end(body);
+  return true;
+}
+var ID_PATTERN2 = /^[A-Za-z0-9][A-Za-z0-9._-]*$/;
+function requireId(res, value, what) {
+  if (value === null || !ID_PATTERN2.test(value)) {
+    sendError(res, new CoreError("bad-request", `\u53C2\u6570 ${what} \u4E0D\u5408\u6CD5\uFF1A${value ?? "(\u7F3A\u5931)"}`, 400));
+    return null;
+  }
+  return value;
+}
+function resolveRepoBinding(params) {
+  const manual = params.manualRepoRoot.trim();
+  if (params.workspaceParam === null) {
+    if (!manual) {
+      return { error: new CoreError("repo-not-configured", "\u5C1A\u672A\u914D\u7F6E\u4E1A\u52A1\u9879\u76EE\u76EE\u5F55\uFF08repoRoot\uFF09\uFF0C\u94FE\u63A5\u91CC\u4E5F\u6CA1\u6709\u5DE5\u4F5C\u533A\u6807\u8BC6\u3002", 400) };
+    }
+    return { root: manual, info: { mode: "manual", title: "\u624B\u52A8\u914D\u7F6E", path: manual, workspaceId: "" } };
+  }
+  if (!ID_PATTERN2.test(params.workspaceParam)) {
+    return { error: new CoreError("bad-request", `\u5DE5\u4F5C\u533A\u6807\u8BC6\u4E0D\u5408\u6CD5\uFF1A${params.workspaceParam}`, 400) };
+  }
+  if (params.registry === void 0) {
+    return {
+      error: new CoreError(
+        "workspace-service-unavailable",
+        "\u5F53\u524D DSH \u6CA1\u6709\u63D0\u4F9B\u5DE5\u4F5C\u533A\u670D\u52A1\uFF08\u53EF\u80FD\u662F DSH \u7248\u672C\u53D8\u5316\uFF09\u3002\u8BF7\u4ECE DSH \u7684\u5DE5\u4F5C\u533A\u91CD\u65B0\u8FDB\u5165\uFF1B\u6216\u6539\u7528\u624B\u52A8\u914D\u7F6E\u6A21\u5F0F\uFF1A\u5728\u63D2\u4EF6\u914D\u7F6E\u91CC\u586B repoRoot\uFF0C\u5E76\u53BB\u6389\u94FE\u63A5\u91CC\u7684 workspace \u53C2\u6570\u3002",
+        503
+      )
+    };
+  }
+  const workspace = params.registry.get(params.workspaceParam);
+  if (workspace === void 0) {
+    return {
+      error: new CoreError(
+        "workspace-not-found",
+        `\u5DE5\u4F5C\u533A\u4E0D\u5B58\u5728\u6216\u5DF2\u5931\u6548\uFF08${params.workspaceParam}\uFF09\u3002\u53EF\u80FD\u8BE5\u5DE5\u4F5C\u533A\u5DF2\u88AB\u5220\u9664\uFF0C\u6216\u8FD9\u4E2A\u94FE\u63A5\u6765\u81EA\u53E6\u4E00\u4E2A DSH \u5B9E\u4F8B\uFF1B\u8BF7\u4ECE DSH \u7684\u5DE5\u4F5C\u533A\u91CD\u65B0\u8FDB\u5165\u3002`,
+        404
+      )
+    };
+  }
+  const root = typeof workspace.path === "string" ? workspace.path.trim() : "";
+  if (!root) {
+    return { error: new CoreError("workspace-not-found", `\u5DE5\u4F5C\u533A ${params.workspaceParam} \u6CA1\u6709\u53EF\u7528\u7684\u76EE\u5F55\u8DEF\u5F84\u3002`, 500) };
+  }
+  const title = typeof workspace.title === "string" && workspace.title.trim() ? workspace.title.trim() : "(\u672A\u547D\u540D\u5DE5\u4F5C\u533A)";
+  return { root, info: { mode: "workspace", title, path: root, workspaceId: params.workspaceParam } };
+}
+function listWorkspaces(registry) {
+  if (registry === void 0) {
+    return {
+      error: new CoreError(
+        "workspace-service-unavailable",
+        "\u5F53\u524D DSH \u6CA1\u6709\u63D0\u4F9B\u5DE5\u4F5C\u533A\u670D\u52A1\uFF08\u53EF\u80FD\u662F DSH \u7248\u672C\u53D8\u5316\uFF09\uFF0C\u5217\u4E0D\u51FA\u5DE5\u4F5C\u533A\u6E05\u5355\u3002",
+        503
+      )
+    };
+  }
+  const workspaces = [];
+  for (const workspace of registry.list()) {
+    const id = typeof workspace.id === "string" ? workspace.id : "";
+    if (!ID_PATTERN2.test(id)) continue;
+    workspaces.push({
+      id,
+      title: typeof workspace.title === "string" && workspace.title.trim() ? workspace.title.trim() : "(\u672A\u547D\u540D\u5DE5\u4F5C\u533A)",
+      path: typeof workspace.path === "string" ? workspace.path : ""
+    });
+  }
+  return { workspaces };
+}
+var BUNDLED_SKILLS = [
+  { dir: "specdev-business", sample: "references/specification.md" },
+  { dir: "specdev-building", sample: "references/blueprint-contract.md" },
+  { dir: "specdev-room", sample: "references/room-contract.md" }
+];
+function parseSkillFrontmatter(raw) {
+  const text = raw.startsWith("\uFEFF") ? raw.slice(1) : raw;
+  if (!text.startsWith("---\n") && !text.startsWith("---\r\n")) return null;
+  const end = text.indexOf("\n---", 4);
+  if (end < 0) return null;
+  let body = text.slice(end + 4);
+  if (body.startsWith("\r")) body = body.slice(1);
+  if (body.startsWith("\n")) body = body.slice(1);
+  if (!body.trim()) return null;
+  let parsedName = "";
+  let description = "";
+  for (const line of text.slice(4, end).split("\n")) {
+    const matched = /^([A-Za-z][A-Za-z0-9_-]*):[ \t]?([^\r\n]*)/.exec(line);
+    if (!matched) continue;
+    if (matched[1] === "name") parsedName = matched[2].trim();
+    else if (matched[1] === "description") description = matched[2].trim();
+  }
+  if (!parsedName || !description) return null;
+  if (!/^[a-z][a-z0-9]*(?:-[a-z0-9]+)*$/.test(parsedName)) return null;
+  return { name: parsedName, description, content: body };
+}
+async function selfCheckSkill(ctx, expected, skillDir, sampleRel, log) {
+  const registry = ctx.skills;
+  if (!registry) return;
+  const listed = (await registry.list()).some((skill) => skill.name === expected.name);
+  const definition = await registry.get(expected.name);
+  let sample;
+  let sampleWhy = "";
+  if (ctx.fs === void 0) sampleWhy = "ctx.fs \u4E0D\u53EF\u7528";
+  else {
+    try {
+      const target = await ctx.fs.resolve(path2.join(skillDir, sampleRel));
+      sample = await ctx.fs.readText(target);
+    } catch (error) {
+      sampleWhy = String(error);
+    }
+  }
+  const contentOk = definition !== void 0 && definition.content === expected.content;
+  const sampleNote = sample === void 0 ? `\u672A\u901A\u8FC7\uFF08${sampleWhy}\uFF09` : `${sample.length} \u5B57`;
+  log(
+    `\u6280\u80FD\u81EA\u67E5\uFF08${expected.name}\uFF09\uFF1Alist ${listed ? "\u5DF2\u89C1" : "\u672A\u89C1"}\uFF1Bget \u6B63\u6587 ${definition === void 0 ? "\u672A\u53D6\u5230" : `${definition.content.length} \u5B57${contentOk ? "\uFF08\u4E0E SKILL.md \u4E00\u81F4\uFF09" : "\uFF08\u4E0E SKILL.md \u4E0D\u4E00\u81F4\uFF09"}`}\uFF1Bfs \u8BFB ${sampleRel} ${sampleNote}`
+  );
+  if (!listed || !contentOk || sample === void 0) {
+    log(`\u6280\u80FD\u81EA\u67E5\u5B58\u5728\u672A\u8FC7\u9879\uFF08${expected.name}\uFF09\uFF1Alist=${listed} \u6B63\u6587=${contentOk} \u53C2\u8003\u6587\u4EF6=${sample !== void 0}`);
+  }
+}
+function registerBundledSkill(ctx, skillDir, sampleRel, log) {
+  let raw;
+  try {
+    raw = readFileSync(path2.join(skillDir, "SKILL.md"), "utf8");
+  } catch (error) {
+    log(`\u968F\u5305\u6280\u80FD\u6CE8\u518C\u5931\u8D25\uFF1A\u8BFB\u4E0D\u5230 ${path2.join(skillDir, "SKILL.md")}\uFF08${String(error)}\uFF09`);
+    return false;
+  }
+  const parsed = parseSkillFrontmatter(raw);
+  if (!parsed) {
+    log("\u968F\u5305\u6280\u80FD\u6CE8\u518C\u5931\u8D25\uFF1ASKILL.md frontmatter \u4E0D\u5408\u5F0F\uFF08\u9700 --- \u5305\u88F9\u7684 name \u4E0E description\uFF0Cname \u987B\u5C0F\u5199\u4E2D\u5212\u7EBF\uFF09");
+    return false;
+  }
+  if (!ctx.skills) {
+    log(`\u968F\u5305\u6280\u80FD\u6CE8\u518C\u8DF3\u8FC7\uFF1Actx.skills \u670D\u52A1\u4E0D\u53EF\u7528\uFF08\u5DF2\u89E3\u6790 ${parsed.name}\uFF09`);
+    return false;
+  }
+  try {
+    const accepted = ctx.skills.register({
+      name: parsed.name,
+      description: parsed.description,
+      content: parsed.content,
+      // source 必填：register() 只代补 invocation/provider，加载侧 validateDefinition 校验 source 必须是字符串。
+      source: "runtime",
+      resourceBase: { kind: "directory", path: skillDir }
+    });
+    if (accepted !== null && typeof accepted === "object" && typeof accepted.then === "function") {
+      void Promise.resolve(accepted).catch((error) => {
+        log(`\u968F\u5305\u6280\u80FD ${parsed.name} \u6CE8\u518C\u5931\u8D25\uFF1A${String(error)}`);
+      });
+    }
+  } catch (error) {
+    log(`\u968F\u5305\u6280\u80FD ${parsed.name} \u6CE8\u518C\u5931\u8D25\uFF1A${String(error)}`);
+    return false;
+  }
+  log(`\u6280\u80FD ${parsed.name} \u5DF2\u6CE8\u518C\uFF08source=runtime\uFF0CresourceBase=${skillDir}\uFF09`);
+  void selfCheckSkill(ctx, parsed, skillDir, sampleRel, log).catch((error) => {
+    log(`\u6280\u80FD ${parsed.name} \u81EA\u67E5\u5931\u8D25\uFF1A${String(error)}`);
+  });
+  return true;
+}
+function apply(ctx, config) {
+  console.error(`[specdev-workbench] apply \u8FD0\u884C\uFF1ArepoRoot=${JSON.stringify(config?.repoRoot ?? "(\u7F3A\u7701)")}\uFF08\u624B\u52A8\u6A21\u5F0F\u515C\u5E95\uFF1B\u5E26 workspace \u7684\u94FE\u63A5\u6309\u8BF7\u6C42\u89E3\u6790\uFF09`);
+  const manualRepoRoot = typeof config?.repoRoot === "string" ? config.repoRoot.trim() : "";
+  const packageRoot = findPackageRoot();
+  const webRoot = path2.join(packageRoot, "web");
+  const vendorRoot = path2.join(packageRoot, "vendor", "archify-renderer");
+  const routeContext = {
+    manualRepoRoot,
+    webRoot,
+    vendorRoot,
+    workspaceRegistry: () => ctx.get("workspaceRegistry")
+  };
+  const dispose = ctx.webServer.register({
+    kind: "prefix",
+    path: "/specdev-workbench",
+    async handler(req, res) {
+      try {
+        if (!authorizeRequest(ctx.connection, req, res)) return;
+        await handle(req, res, routeContext);
+      } catch (error) {
+        if (!res.headersSent) sendError(res, error);
+        else res.end();
+      }
+    }
+  });
+  console.error("[specdev-workbench] /specdev-workbench \u524D\u7F00\u8DEF\u7531\u5DF2\u6CE8\u518C\uFF08\u5165\u53E3\u7EDF\u4E00\u8BA4\u8BC1\uFF0Cfail-closed\uFF09");
+  ctx.effect(() => dispose, "\u6D41\u7A0B\u56FE\u7BA1\u7406\u8DEF\u7531\u6E05\u7406");
+  const log = (message) => console.error(`[specdev-workbench] ${message}`);
+  for (const skill of BUNDLED_SKILLS) {
+    registerBundledSkill(ctx, path2.join(packageRoot, "skills", skill.dir), skill.sample, log);
+  }
+}
+function authorizeRequest(connection, req, res) {
+  let rejection = 503;
+  if (connection !== null && typeof connection === "object" && typeof connection.requestRejection === "function") {
+    try {
+      rejection = connection.requestRejection(req);
+    } catch {
+      rejection = 503;
+    }
+  }
+  if (rejection === void 0) return true;
+  const status = rejection === 401 || rejection === 403 ? rejection : 503;
+  const isApi = (req.url ?? "").split("?")[0].split("/").filter((s) => s !== "")[1] === "api";
+  if (isApi) {
+    const body = status === 401 ? { code: "unauthorized", error: "\u672A\u767B\u5F55\u6216\u4F1A\u8BDD\u5DF2\u8FC7\u671F\uFF1A\u8BF7\u5148\u6253\u5F00 DSH \u542F\u52A8\u5730\u5740\u5B8C\u6210\u767B\u5F55\uFF0C\u518D\u4F7F\u7528\u6D41\u7A0B\u56FE\u7BA1\u7406\u3002" } : status === 403 ? { code: "forbidden", error: "\u8BF7\u6C42\u6765\u6E90\u4E0D\u88AB\u4FE1\u4EFB\uFF08Host/Origin \u6821\u9A8C\u672A\u901A\u8FC7\uFF09\uFF0C\u5DF2\u62D2\u7EDD\u8BBF\u95EE\u3002" } : { code: "auth-unavailable", error: "\u8BA4\u8BC1\u670D\u52A1\u4E0D\u53EF\u7528\uFF0C\u5DF2\u62D2\u7EDD\u8BBF\u95EE\uFF08fail-closed\uFF0C\u4E0D\u653E\u884C\uFF09\u3002" };
+    sendJson(res, status, body);
+    return false;
+  }
+  const text = status === 401 ? "\u8BF7\u5148\u901A\u8FC7 DSH \u542F\u52A8\u5730\u5740\u767B\u5F55\n" : status === 403 ? "\u8BF7\u6C42\u6765\u6E90\u4E0D\u88AB\u4FE1\u4EFB\uFF08Host/Origin \u6821\u9A8C\u672A\u901A\u8FC7\uFF09\uFF0C\u5DF2\u62D2\u7EDD\u8BBF\u95EE\u3002\n" : "\u8BA4\u8BC1\u670D\u52A1\u4E0D\u53EF\u7528\uFF0C\u5DF2\u62D2\u7EDD\u8BBF\u95EE\u3002\n";
+  res.writeHead(status, { "Content-Type": "text/plain; charset=utf-8", "Cache-Control": "no-store" });
+  res.end(text);
+  return false;
+}
+async function handle(req, res, ctx) {
+  const url = new URL(req.url ?? "/", "http://127.0.0.1");
+  const segments = url.pathname.split("/").filter((s) => s !== "");
+  const apiPost = req.method === "POST" && segments.length === 3 && segments[1] === "api" && (segments[2] === "evidence" || segments[2] === "snapshots");
+  if (req.method !== "GET" && req.method !== "HEAD" && !apiPost) {
+    sendError(res, new CoreError("bad-request", "\u63A5\u53E3\u53EA\u8BFB\uFF08GET/HEAD\uFF09\uFF1B\u4EC5 POST /api/evidence \u4E0E POST /api/snapshots \u4F8B\u5916", 405));
+    return;
+  }
+  if (segments.length === 1) {
+    if (await serveFile(res, ctx.webRoot, "index.html")) return;
+  } else if (segments.length === 2 && segments[1] === "workspaces") {
+    if (await serveFile(res, ctx.webRoot, "workspaces.html")) return;
+  } else if (segments.length === 2 && segments[1] === "business") {
+    if (await serveFile(res, ctx.webRoot, "business.html")) return;
+  } else if (segments.length === 3 && segments[1] === "business" && ID_PATTERN2.test(segments[2])) {
+    if (await serveFile(res, ctx.webRoot, "business.html")) return;
+  } else if (segments.length === 2 && segments[1] === "showcase") {
+    if (await serveFile(res, ctx.webRoot, "showcase.html")) return;
+  } else if (segments.length === 2 && segments[1] === "building") {
+    if (await serveFile(res, ctx.webRoot, "building.html")) return;
+  } else if (segments.length >= 3 && segments[1] === "read") {
+    if (await serveFile(res, ctx.webRoot, "read.html")) return;
+  } else if (segments.length === 3 && segments[1] === "room" && ID_PATTERN2.test(segments[2])) {
+    if (await serveFile(res, ctx.webRoot, "room.html")) return;
+  } else if (segments.length === 2 && segments[1] === "furniture") {
+    if (await serveFile(res, ctx.webRoot, "furniture.html")) return;
+  }
+  if (segments[1] === "assets" && segments.length > 2) {
+    if (await serveFile(res, path2.join(ctx.webRoot, "assets"), segments.slice(2).join("/"))) return;
+  }
+  if (segments[1] === "vendor" && segments.length > 2) {
+    if (await serveFile(res, ctx.vendorRoot, segments.slice(2).join("/"))) return;
+  }
+  if (segments[1] === "api") {
+    await handleApi(req, url, res, ctx);
+    return;
+  }
+  sendError(res, new CoreError("not-found", `\u8DEF\u5F84\u4E0D\u5B58\u5728\uFF1A${url.pathname}`, 404));
+}
+async function handleApi(req, url, res, ctx) {
+  const api = url.pathname.split("/").filter((s) => s !== "")[2];
+  const q = url.searchParams;
+  if (api === "workspaces") {
+    const listed = listWorkspaces(ctx.workspaceRegistry());
+    if ("error" in listed) return sendError(res, listed.error);
+    sendJson(res, 200, listed);
+    return;
+  }
+  const binding = resolveRepoBinding({
+    workspaceParam: q.get("workspace"),
+    manualRepoRoot: ctx.manualRepoRoot,
+    registry: ctx.workspaceRegistry()
+  });
+  if ("error" in binding) {
+    if (binding.error.code === "repo-not-configured") return repoNotConfigured(res);
+    return sendError(res, binding.error);
+  }
+  await assertRepoUsable(binding.root);
+  if (binding.info.mode === "workspace") await assertRepoTopLevel(binding.root);
+  const root = binding.root;
+  try {
+    await dispatchApi(api, req, q, res, { root, repo: binding.info });
+  } catch (error) {
+    if (error instanceof CoreError) {
+      sendJson(res, error.httpStatus, { code: error.code, error: error.message, repo: binding.info });
+      return;
+    }
+    throw error;
+  }
+}
+async function dispatchApi(api, req, q, res, ctx) {
+  const root = ctx.root;
+  if (api === "inventory") {
+    sendJson(res, 200, { ...await readInventory(root), repo: ctx.repo });
+    return;
+  }
+  if (api === "building") {
+    const binding = await readBuildingBinding(root);
+    const view = q.get("view");
+    let present;
+    if (binding.ok && binding.model && (view === "frame" || view === "preview")) {
+      present = presentBuilding(binding.model, { preview: view === "preview" });
+    }
+    sendJson(res, 200, { ...binding, repo: ctx.repo, ...present !== void 0 ? { present } : {} });
+    return;
+  }
+  if (api === "room") {
+    const business = requireId(res, q.get("business"), "business");
+    if (!business) return;
+    sendJson(res, 200, { ...await readRoomLayout(root, business), repo: ctx.repo });
+    return;
+  }
+  if (api === "chart") {
+    const business = requireId(res, q.get("business"), "business");
+    if (!business) return;
+    const chart = requireId(res, q.get("chart"), "chart");
+    if (!chart) return;
+    const v = q.get("v") || "current";
+    const page = await readChartPage(root, business, chart, v);
+    sendJson(res, 200, { ...page, repo: ctx.repo });
+    return;
+  }
+  if (api === "evidence") {
+    if (req.method === "POST") {
+      const text = await readRequestText(req, res);
+      if (text === null) return;
+      sendJson(res, 200, await loadEvidence(root, text));
+      return;
+    }
+    const business = requireId(res, q.get("business"), "business");
+    if (!business) return;
+    const chart = requireId(res, q.get("chart"), "chart");
+    if (!chart) return;
+    const v = q.get("v") || "current";
+    const page = await readChartPage(root, business, chart, v);
+    if (page.version.evidenceError) {
+      sendJson(res, 200, { missing: false, parseError: page.version.evidenceError, refs: [] });
+      return;
+    }
+    const evidence = await loadEvidence(root, page.version.files.evidence);
+    sendJson(res, 200, evidence);
+    return;
+  }
+  if (api === "snapshots") {
+    if (req.method === "POST") {
+      const text = await readRequestText(req, res);
+      if (text === null) return;
+      let body;
+      try {
+        body = JSON.parse(text);
+      } catch {
+        sendError(res, new CoreError("bad-request", "\u4FDD\u5B58\u8BF7\u6C42\u6B63\u6587\u5FC5\u987B\u662F JSON", 400));
+        return;
+      }
+      const fields = typeof body === "object" && body !== null ? body : {};
+      const business2 = requireId(res, typeof fields.business === "string" ? fields.business : null, "business");
+      if (!business2) return;
+      const chart2 = requireId(res, typeof fields.chart === "string" ? fields.chart : null, "chart");
+      if (!chart2) return;
+      const result = await saveChartSnapshot(root, business2, chart2, body, {
+        expectedHead: typeof fields.head === "string" ? fields.head : "",
+        fingerprint: typeof fields.fingerprint === "string" ? fields.fingerprint : ""
+      });
+      sendJson(res, 200, result);
+      return;
+    }
+    const business = requireId(res, q.get("business"), "business");
+    if (!business) return;
+    const chart = requireId(res, q.get("chart"), "chart");
+    if (!chart) return;
+    sendJson(res, 200, await checkChartCommitted(root, business, chart));
+    return;
+  }
+  if (api === "doc") {
+    const business = requireId(res, q.get("business"), "business");
+    if (!business) return;
+    const docPath = q.get("path");
+    if (!docPath) {
+      sendError(res, new CoreError("bad-request", "\u7F3A\u5C11 path \u53C2\u6570", 400));
+      return;
+    }
+    const inventory = await readInventory(root);
+    const entry = inventory.businesses.find((b) => b.id === business);
+    if (!entry || !entry.docs.includes(docPath)) {
+      sendError(res, new CoreError("not-found", `\u6587\u6863\u672A\u5728\u4E1A\u52A1 ${business} \u7684 docs \u91CC\u58F0\u660E\uFF1A${docPath}`, 404));
+      return;
+    }
+    const text = await readWorktreeFileOptional(root, docPath);
+    if (text === null) {
+      sendError(res, new CoreError("not-found", `\u6587\u6863\u4E0D\u5B58\u5728\uFF08\u5DE5\u4F5C\u533A\uFF09\uFF1A${docPath}`, 404));
+      return;
+    }
+    res.writeHead(200, { "Content-Type": "text/plain; charset=utf-8", "Cache-Control": "no-store" });
+    res.end(text);
+    return;
+  }
+  sendError(res, new CoreError("not-found", `\u63A5\u53E3\u4E0D\u5B58\u5728\uFF1A${api ?? "(\u7F3A\u5931)"}`, 404));
+}
+export {
+  BUNDLED_SKILLS,
+  apply,
+  authorizeRequest,
+  inject,
+  listWorkspaces,
+  name,
+  parseSkillFrontmatter,
+  registerBundledSkill,
+  resolveRepoBinding
+};