@vinsonw2/asset-compound 0.0.0-stage → 0.1.1

package/dist/chunk-P2MVWNYS.js

@@ -0,0 +1,1014 @@
+// src/schema.ts
+import { Ajv2020 } from "ajv/dist/2020.js";
+import formatsPlugin from "ajv-formats";
+var dimension = {
+  type: "object",
+  additionalProperties: false,
+  required: ["level", "evidence", "gaps", "recommendations"],
+  properties: {
+    level: {
+      enum: ["ready", "partial", "missing", "conflict", "high", "medium", "low"]
+    },
+    evidence: { type: "array", items: { type: "string" } },
+    gaps: { type: "array", items: { type: "string" } },
+    recommendations: { type: "array", items: { type: "string" } }
+  }
+};
+var assetSchema = {
+  $schema: "https://json-schema.org/draft/2020-12/schema",
+  type: "object",
+  additionalProperties: false,
+  required: [
+    "assetId",
+    "sourceType",
+    "sourceRef",
+    "sourceRevision",
+    "contentHash",
+    "title",
+    "summary",
+    "facts",
+    "decisions",
+    "actions",
+    "relations",
+    "analysis",
+    "writebackKind"
+  ],
+  properties: {
+    assetId: { type: "string", pattern: "^sha256:[a-f0-9]{64}$" },
+    sourceType: { enum: ["requirement", "design", "ai-artifact", "git"] },
+    sourceRef: { type: "string", minLength: 1 },
+    sourceRevision: { type: "string", minLength: 1 },
+    contentHash: { type: "string", pattern: "^sha256:[a-f0-9]{64}$" },
+    title: { type: "string", minLength: 1 },
+    summary: { type: "string" },
+    facts: { type: "array", items: { type: "string" } },
+    decisions: { type: "array", items: { type: "string" } },
+    actions: { type: "array", items: { type: "string" } },
+    relations: { type: "array", items: { type: "string" } },
+    analysis: {
+      type: "object",
+      additionalProperties: false,
+      required: ["completeness", "executability", "consistency", "reuseValue"],
+      properties: {
+        completeness: dimension,
+        executability: dimension,
+        consistency: dimension,
+        reuseValue: dimension
+      }
+    },
+    writebackKind: { enum: ["\u65B0\u589E", "\u589E\u91CF", "\u672A\u53D8"] }
+  }
+};
+var configSchema = {
+  type: "object",
+  additionalProperties: false,
+  required: ["outputRoot", "sourceSets"],
+  properties: {
+    outputRoot: { const: "docs/\u53EF\u8BFB\u5316" },
+    baseBranch: { type: "string", minLength: 1 },
+    sourceSets: {
+      type: "array",
+      minItems: 2,
+      items: {
+        type: "object",
+        additionalProperties: false,
+        required: ["type"],
+        properties: {
+          type: { enum: ["requirement", "design", "ai-artifact", "git"] },
+          include: { type: "array", items: { type: "string" } },
+          maxCommits: { type: "integer", minimum: 1, maximum: 1e3 }
+        }
+      }
+    },
+    exclude: { type: "array", items: { type: "string" } }
+  }
+};
+var stateSchema = {
+  type: "object",
+  additionalProperties: false,
+  required: [
+    "schemaVersion",
+    "selfHash",
+    "baseBranch",
+    "baseCommit",
+    "lastReadCommit",
+    "sources",
+    "assets",
+    "managedFiles"
+  ],
+  properties: {
+    schemaVersion: { const: 1 },
+    selfHash: { type: "string", pattern: "^sha256:[a-f0-9]{64}$" },
+    baseBranch: { type: "string" },
+    baseCommit: { type: "string" },
+    lastReadCommit: { type: "string" },
+    sources: {
+      type: "object",
+      additionalProperties: {
+        type: "object",
+        additionalProperties: false,
+        required: ["contentHash", "sourceRevision", "assetIds", "status"],
+        properties: {
+          contentHash: { type: "string", pattern: "^sha256:[a-f0-9]{64}$" },
+          sourceRevision: { type: "string", minLength: 1 },
+          assetIds: {
+            type: "array",
+            items: { type: "string", pattern: "^sha256:[a-f0-9]{64}$" }
+          },
+          status: { enum: ["active", "stale"] }
+        }
+      }
+    },
+    assets: {
+      type: "object",
+      additionalProperties: {
+        type: "object",
+        additionalProperties: false,
+        required: ["canonicalContentHash", "outputPath", "lastGeneratedHash"],
+        properties: {
+          canonicalContentHash: { type: "string", pattern: "^sha256:[a-f0-9]{64}$" },
+          outputPath: {
+            type: "string",
+            pattern: "^(?!.*(?:^|/)\\.\\.(?:/|$))docs/\u53EF\u8BFB\u5316/.+$"
+          },
+          lastGeneratedHash: { type: "string", pattern: "^sha256:[a-f0-9]{64}$" }
+        }
+      }
+    },
+    managedFiles: {
+      type: "object",
+      propertyNames: {
+        pattern: "^(?!.*(?:^|/)\\.\\.(?:/|$))docs/\u53EF\u8BFB\u5316/.+$"
+      },
+      additionalProperties: { type: "string", pattern: "^sha256:[a-f0-9]{64}$" }
+    }
+  }
+};
+var ajv = new Ajv2020({ strict: true, allErrors: true });
+formatsPlugin(ajv);
+function compile(schema) {
+  return ajv.compile(schema);
+}
+var validateAsset = compile(assetSchema);
+var validateConfig = compile(configSchema);
+var validateState = compile(stateSchema);
+function assertValid(validator, value, label) {
+  if (!validator(value)) {
+    const details = (validator.errors ?? []).map((error) => `${error.instancePath || "/"} ${error.message}`).sort().join("; ");
+    throw new Error(`${label} \u672A\u901A\u8FC7 schema \u6821\u9A8C\uFF1A${details}`);
+  }
+}
+
+// src/pipeline.ts
+import { execFile } from "child_process";
+import { createHash } from "crypto";
+import { access, lstat, mkdir, readFile, realpath } from "fs/promises";
+import path from "path";
+import { promisify } from "util";
+import fg from "fast-glob";
+import writeFileAtomic from "write-file-atomic";
+import { parse as parseYaml, stringify as stringifyYaml } from "yaml";
+var execFileAsync = promisify(execFile);
+var OUTPUT_ROOT = "docs/\u53EF\u8BFB\u5316";
+var SOURCE_TYPE_LABEL = {
+  requirement: "\u9700\u6C42",
+  design: "\u8BBE\u8BA1",
+  "ai-artifact": "AI \u4EA7\u7269",
+  git: "Git \u5386\u53F2"
+};
+var LEVEL_LABEL = {
+  ready: "\u5C31\u7EEA",
+  partial: "\u90E8\u5206\u6EE1\u8DB3",
+  missing: "\u7F3A\u5931",
+  conflict: "\u51B2\u7A81",
+  high: "\u9AD8",
+  medium: "\u4E2D",
+  low: "\u4F4E"
+};
+function sha256(value) {
+  const normalized = typeof value === "string" ? value.replace(/\r\n?/g, "\n").normalize("NFC") : value;
+  return `sha256:${createHash("sha256").update(normalized).digest("hex")}`;
+}
+async function exists(file) {
+  try {
+    await access(file);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function git(repo, args) {
+  const { stdout } = await execFileAsync("git", args, {
+    cwd: repo,
+    encoding: "utf8",
+    maxBuffer: 20 * 1024 * 1024
+  });
+  return stdout.trimEnd();
+}
+async function assertOutputPath(repo, target) {
+  const root = await realpath(repo);
+  const absolute = path.resolve(root, target);
+  const relative = path.relative(root, absolute);
+  if (path.isAbsolute(relative) || relative === ".." || relative.startsWith(`..${path.sep}`) || !(relative === OUTPUT_ROOT || relative.startsWith(`${OUTPUT_ROOT}${path.sep}`))) {
+    throw new Error(`\u62D2\u7EDD\u5199\u5165 ${OUTPUT_ROOT} \u4E4B\u5916\u7684\u8DEF\u5F84\uFF1A${target}`);
+  }
+  let cursor = root;
+  for (const segment of relative.split(path.sep)) {
+    cursor = path.join(cursor, segment);
+    if (await exists(cursor)) {
+      const stat2 = await lstat(cursor);
+      if (stat2.isSymbolicLink()) {
+        throw new Error(`\u62D2\u7EDD\u8F93\u51FA\u8DEF\u5F84\u4E2D\u7684\u7B26\u53F7\u94FE\u63A5\uFF1A${cursor}`);
+      }
+    }
+  }
+  return absolute;
+}
+async function atomicWriteIfChanged(repo, relativePath, content) {
+  const target = await assertOutputPath(repo, relativePath);
+  const normalized = `${content.replace(/\r\n?/g, "\n").trimEnd()}
+`;
+  if (await exists(target)) {
+    const current = await readFile(target, "utf8");
+    if (current === normalized) return false;
+  }
+  await mkdir(path.dirname(target), { recursive: true });
+  await writeFileAtomic(target, normalized, { encoding: "utf8", fsync: true });
+  return true;
+}
+async function loadConfig(configPath) {
+  const value = parseYaml(await readFile(configPath, "utf8"));
+  assertValid(validateConfig, value, "\u8FD0\u884C\u914D\u7F6E");
+  const types = new Set(value.sourceSets.map((source) => source.type));
+  if (types.size < 2) {
+    throw new Error("V2 \u8981\u6C42\u81F3\u5C11\u4E24\u79CD\u4E0D\u540C\u7684\u6765\u6E90\u7C7B\u578B");
+  }
+  return value;
+}
+async function plan(repo, configPath) {
+  const repoRoot = await realpath(repo);
+  const config = await loadConfig(configPath);
+  const inside = await git(repoRoot, ["rev-parse", "--is-inside-work-tree"]);
+  if (inside !== "true") throw new Error("\u76EE\u6807\u8DEF\u5F84\u4E0D\u662F Git \u5DE5\u4F5C\u6811");
+  return {
+    repoRoot,
+    outputRoot: config.outputRoot,
+    sourceTypes: [...new Set(config.sourceSets.map((source) => source.type))].sort(),
+    baseCommit: await git(repoRoot, ["rev-parse", "HEAD"])
+  };
+}
+async function fileRevision(repo, file) {
+  try {
+    return await git(repo, ["log", "-1", "--format=%H", "--", file]) || "untracked";
+  } catch {
+    return "untracked";
+  }
+}
+async function scanFileSet(repo, source, excludes) {
+  if (!source.include?.length) {
+    throw new Error(`${SOURCE_TYPE_LABEL[source.type]}\u6765\u6E90\u5FC5\u987B\u914D\u7F6E include glob`);
+  }
+  const files = await fg(source.include, {
+    cwd: repo,
+    onlyFiles: true,
+    unique: true,
+    dot: false,
+    followSymbolicLinks: false,
+    ignore: excludes
+  });
+  files.sort();
+  if (files.length === 0) {
+    throw new Error(`${SOURCE_TYPE_LABEL[source.type]}\u6765\u6E90\u4E3A\u7A7A`);
+  }
+  return Promise.all(
+    files.map(async (file) => {
+      if (redactSensitive(file) !== file) {
+        throw new Error(`\u62D2\u7EDD\u5305\u542B\u654F\u611F\u4FE1\u606F\u7684\u6765\u6E90\u8DEF\u5F84\uFF1A${file}`);
+      }
+      const root = await realpath(repo);
+      const absolute = path.resolve(root, file);
+      const relative = path.relative(root, absolute);
+      if (path.isAbsolute(relative) || relative === ".." || relative.startsWith(`..${path.sep}`)) {
+        throw new Error(`\u62D2\u7EDD\u8BFB\u53D6\u4ED3\u5E93\u4E4B\u5916\u7684\u6765\u6E90\uFF1A${file}`);
+      }
+      const stat2 = await lstat(absolute);
+      if (stat2.isSymbolicLink()) throw new Error(`\u62D2\u7EDD\u7B26\u53F7\u94FE\u63A5\u6765\u6E90\uFF1A${file}`);
+      const resolvedSource = await realpath(absolute);
+      if (resolvedSource !== absolute) {
+        throw new Error(`\u62D2\u7EDD\u901A\u8FC7\u7B26\u53F7\u94FE\u63A5\u9003\u9038\u4ED3\u5E93\u7684\u6765\u6E90\uFF1A${file}`);
+      }
+      const buffer = await readFile(absolute);
+      const text = buffer.toString("utf8");
+      const isText = /\.(?:md|mdx|txt|json|ya?ml|tsx?|jsx?|css|html)$/i.test(file);
+      return {
+        sourceType: source.type,
+        sourceRef: file.split(path.sep).join("/"),
+        sourceRevision: await fileRevision(repo, file),
+        contentHash: sha256(isText ? text : buffer),
+        content: text
+      };
+    })
+  );
+}
+async function scanGitSet(repo, source) {
+  const maxCommits = source.maxCommits ?? 20;
+  const output = await git(repo, [
+    "log",
+    `-${maxCommits}`,
+    "--format=%H%x1f%s%x1f%b%x1f%aI%x00"
+  ]);
+  const records = output.split("\0").map((record) => record.trim()).filter(Boolean).map((record) => {
+    const [commit = "", subject = "", body = "", authoredAt = ""] = record.split("");
+    const content = [subject, body, authoredAt].filter(Boolean).join("\n");
+    return {
+      sourceType: "git",
+      sourceRef: `git:${commit}`,
+      sourceRevision: commit,
+      contentHash: sha256(content),
+      content
+    };
+  });
+  if (records.length === 0) throw new Error("Git \u5386\u53F2\u6765\u6E90\u4E3A\u7A7A");
+  return records;
+}
+async function scan(repo, config) {
+  const excludes = [
+    `${OUTPUT_ROOT}/**`,
+    "node_modules/**",
+    "dist/**",
+    ...config.exclude ?? []
+  ];
+  const groups = await Promise.all(
+    config.sourceSets.map(
+      (source) => source.type === "git" ? scanGitSet(repo, source) : scanFileSet(repo, source, excludes)
+    )
+  );
+  const records = groups.flat().sort(
+    (a, b) => `${a.sourceType}:${a.sourceRef}`.localeCompare(`${b.sourceType}:${b.sourceRef}`)
+  );
+  const nonEmptyTypes = new Set(records.map((record) => record.sourceType));
+  if (nonEmptyTypes.size < 2) {
+    throw new Error("V2 \u8981\u6C42\u81F3\u5C11\u4E24\u7C7B\u771F\u5B9E\u4E14\u975E\u7A7A\u7684\u6765\u6E90");
+  }
+  return records;
+}
+function titleFor(record) {
+  const content = redactSensitive(record.content);
+  if (record.sourceType === "git") {
+    return content.split("\n")[0]?.trim() || record.sourceRevision.slice(0, 12);
+  }
+  const heading = content.match(/^#\s+(.+)$/m)?.[1]?.trim();
+  return heading || path.basename(record.sourceRef, path.extname(record.sourceRef));
+}
+function compactLines(content) {
+  return content.replace(/^#{1,6}\s+/gm, "").split(/\n+/).map((line) => line.trim()).filter(Boolean);
+}
+function redactSensitive(value) {
+  return value.replace(/\b[A-Z0-9._%+-]+@[A-Z0-9.-]+\.[A-Z]{2,}\b/gi, "[REDACTED_EMAIL]").replace(/\b(?:gh[pousr]_[A-Za-z0-9_]{20,}|AKIA[A-Z0-9]{16})\b/g, "[REDACTED_SECRET]").replace(
+    /\b(api[_-]?key|token|secret|password)\s*[:=]\s*["']?[^\s"'`]+/gi,
+    "$1=[REDACTED_SECRET]"
+  );
+}
+function prepare(records, previous) {
+  return records.map((record) => {
+    const sourceKey = `${record.sourceType}:${record.sourceRef}`;
+    const old = previous?.sources[sourceKey];
+    const writebackKind = old?.contentHash === record.contentHash ? "\u672A\u53D8" : old ? "\u589E\u91CF" : "\u65B0\u589E";
+    const lines = compactLines(redactSensitive(record.content));
+    const evidence = [`${record.sourceRef}@${record.sourceRevision}`];
+    const hasActions = lines.some((line) => /(^|\s)(must|should|todo|需要|必须|应当)/i.test(line));
+    const summary = lines.join(" ").slice(0, 280);
+    const asset = {
+      assetId: sha256(sourceKey),
+      sourceType: record.sourceType,
+      sourceRef: record.sourceRef,
+      sourceRevision: record.sourceRevision,
+      contentHash: record.contentHash,
+      title: titleFor(record),
+      summary,
+      facts: lines.slice(0, 5),
+      decisions: [],
+      actions: hasActions ? lines.filter((line) => /must|should|todo|需要|必须|应当/i.test(line)).slice(0, 5) : [],
+      relations: [],
+      analysis: {
+        completeness: {
+          level: summary.length >= 80 ? "partial" : "missing",
+          evidence,
+          gaps: ["\u9700\u8981\u4EBA\u5DE5\u786E\u8BA4\u8303\u56F4\u3001\u7EA6\u675F\u4E0E\u9A8C\u6536\u8FB9\u754C"],
+          recommendations: ["\u7531 Skill \u57FA\u4E8E\u4E1A\u52A1\u4E0A\u4E0B\u6587\u8865\u5168\u5B8C\u6574\u6027\u5206\u6790"]
+        },
+        executability: {
+          level: hasActions ? "partial" : "missing",
+          evidence,
+          gaps: hasActions ? ["\u884C\u52A8\u9879\u8D1F\u8D23\u4EBA\u548C\u5B8C\u6210\u6761\u4EF6\u5F85\u786E\u8BA4"] : ["\u672A\u8BC6\u522B\u5230\u660E\u786E\u884C\u52A8\u9879"],
+          recommendations: ["\u8865\u5145\u8D1F\u8D23\u4EBA\u3001\u524D\u7F6E\u6761\u4EF6\u548C\u53EF\u9A8C\u8BC1\u5B8C\u6210\u6807\u51C6"]
+        },
+        consistency: {
+          level: "partial",
+          evidence,
+          gaps: ["\u9700\u8981\u8DE8\u8D44\u4EA7\u5BF9\u7167\u540E\u786E\u8BA4\u4E00\u81F4\u6027"],
+          recommendations: ["\u5C06\u76F8\u5173\u9700\u6C42\u3001\u8BBE\u8BA1\u548C\u5386\u53F2\u51B3\u7B56\u8FDB\u884C\u4EA4\u53C9\u6838\u9A8C"]
+        },
+        reuseValue: {
+          level: lines.length >= 3 ? "medium" : "low",
+          evidence,
+          gaps: ["\u590D\u7528\u573A\u666F\u4E0E\u9002\u7528\u8FB9\u754C\u5F85\u786E\u8BA4"],
+          recommendations: ["\u63D0\u70BC\u53EF\u590D\u5236\u7684\u51B3\u7B56\u3001\u68C0\u67E5\u8868\u6216\u6A21\u677F"]
+        }
+      },
+      writebackKind
+    };
+    assertValid(validateAsset, asset, `\u8D44\u4EA7 ${asset.assetId}`);
+    return asset;
+  });
+}
+async function loadAssetsFile(file, records) {
+  const value = JSON.parse(await readFile(file, "utf8"));
+  if (!Array.isArray(value)) throw new Error("\u589E\u5F3A\u8D44\u4EA7\u8F93\u5165\u5FC5\u987B\u662F JSON \u6570\u7EC4");
+  const assets = value.map((candidate, index) => {
+    assertValid(validateAsset, candidate, `\u8D44\u4EA7\u8F93\u5165 ${index}`);
+    const serialized = JSON.stringify(candidate);
+    if (redactSensitive(serialized) !== serialized) {
+      throw new Error(`\u8D44\u4EA7\u8F93\u5165 ${index} \u5305\u542B\u654F\u611F\u6570\u636E`);
+    }
+    return candidate;
+  });
+  const sourceKeys = assets.map((asset) => `${asset.sourceType}:${asset.sourceRef}`);
+  if (new Set(sourceKeys).size !== assets.length || new Set(assets.map((asset) => asset.assetId)).size !== assets.length) {
+    throw new Error("\u589E\u5F3A\u8D44\u4EA7\u8F93\u5165\u5305\u542B\u91CD\u590D\u6765\u6E90\u6216\u91CD\u590D\u8D44\u4EA7 ID");
+  }
+  if (records) {
+    const bySource = new Map(
+      records.map((record) => [`${record.sourceType}:${record.sourceRef}`, record])
+    );
+    for (const asset of assets) {
+      const record = bySource.get(`${asset.sourceType}:${asset.sourceRef}`);
+      if (!record) throw new Error(`\u8D44\u4EA7\u6765\u6E90\u4E0D\u5728\u672C\u6B21\u626B\u63CF\u4E2D\uFF1A${asset.sourceRef}`);
+      if (asset.assetId !== sha256(`${record.sourceType}:${record.sourceRef}`) || asset.contentHash !== record.contentHash || asset.sourceRevision !== record.sourceRevision) {
+        throw new Error(`\u8D44\u4EA7\u6765\u6E90\u8FFD\u8E2A\u5B57\u6BB5\u88AB\u4FEE\u6539\uFF1A${asset.sourceRef}`);
+      }
+    }
+    if (assets.length !== records.length) {
+      throw new Error("\u589E\u5F3A\u8D44\u4EA7\u8F93\u5165\u5FC5\u987B\u4E3A\u6BCF\u4E2A\u626B\u63CF\u6765\u6E90\u63D0\u4F9B\u4E14\u4EC5\u63D0\u4F9B\u4E00\u6761\u8D44\u4EA7");
+    }
+    const expectedSources = new Set(bySource.keys());
+    if (sourceKeys.some((key) => !expectedSources.has(key))) {
+      throw new Error("\u589E\u5F3A\u8D44\u4EA7\u8F93\u5165\u4E0E\u672C\u6B21\u626B\u63CF\u4E0D\u5339\u914D");
+    }
+  }
+  return assets;
+}
+function renderDimension(label, finding) {
+  const bullets = (items) => items.length ? items.map((item) => `- ${redactSensitive(item)}`).join("\n") : "- \u65E0";
+  return `### ${label}\uFF1A${LEVEL_LABEL[finding.level]}
+
+**\u8BC1\u636E**
+${bullets(finding.evidence)}
+
+**\u7F3A\u53E3**
+${bullets(finding.gaps)}
+
+**\u5EFA\u8BAE**
+${bullets(finding.recommendations)}`;
+}
+function renderAsset(asset) {
+  return `# ${redactSensitive(asset.title)}
+
+- \u6807\u8BB0\uFF1A${asset.writebackKind}
+- \u7C7B\u578B\uFF1A${SOURCE_TYPE_LABEL[asset.sourceType]}
+- \u6765\u6E90\uFF1A\`${redactSensitive(asset.sourceRef)}\`
+- \u6765\u6E90\u7248\u672C\uFF08sourceRevision\uFF09\uFF1A\`${asset.sourceRevision}\`
+- \u5185\u5BB9\u6307\u7EB9\uFF08contentHash\uFF09\uFF1A\`${asset.contentHash}\`
+- \u8D44\u4EA7 ID\uFF08assetId\uFF09\uFF1A\`${asset.assetId}\`
+
+## \u6458\u8981
+
+${redactSensitive(asset.summary) || "\u65E0\u53EF\u63D0\u53D6\u6458\u8981\u3002"}
+
+## \u56DB\u7EF4\u5206\u6790
+
+${renderDimension("\u5B8C\u6574\u6027", asset.analysis.completeness)}
+
+${renderDimension("\u53EF\u6267\u884C\u6027", asset.analysis.executability)}
+
+${renderDimension("\u4E00\u81F4\u6027", asset.analysis.consistency)}
+
+${renderDimension("\u590D\u7528\u4EF7\u503C", asset.analysis.reuseValue)}
+`;
+}
+async function readState(repo) {
+  const statePath = path.join(repo, OUTPUT_ROOT, "state/read-state.json");
+  if (!await exists(statePath)) return null;
+  const value = JSON.parse(await readFile(statePath, "utf8"));
+  assertValid(validateState, value, "\u8BFB\u53D6\u72B6\u6001");
+  const expected = sha256(JSON.stringify({ ...value, selfHash: "" }, null, 2));
+  if (value.selfHash !== expected) {
+    throw new Error("\u8BFB\u53D6\u72B6\u6001\u7684 selfHash \u4E0D\u5339\u914D\uFF1B\u62D2\u7EDD\u8986\u76D6\u5DF2\u7F16\u8F91\u7684 state");
+  }
+  return value;
+}
+function renderIndex(assets) {
+  const rows = assets.map(
+    (asset) => `| [${redactSensitive(asset.title)}](assets/${asset.assetId.slice(7)}.md) | ${SOURCE_TYPE_LABEL[asset.sourceType]} | ${asset.writebackKind} | \`${redactSensitive(asset.sourceRef)}\` |`
+  ).join("\n");
+  return `# \u8D44\u4EA7\u590D\u5229\u7D22\u5F15
+
+> \u672C\u76EE\u5F55\u7531 asset-compound \u7BA1\u7406\u3002\u793A\u4F8B fixture \u4E0D\u80FD\u4F5C\u4E3A\u771F\u5B9E\u9A8C\u6536\u6570\u636E\u3002
+
+| \u8D44\u4EA7 | \u7C7B\u578B | \u6807\u8BB0 | \u6765\u6E90 |
+|---|---|---|---|
+${rows}
+`;
+}
+async function loadTemplate(name) {
+  return readFile(new URL(`../templates/${name}`, import.meta.url), "utf8");
+}
+async function renderConflicts(runId, conflicts) {
+  const details = conflicts.length === 0 ? "\u672C\u6B21\u68C0\u67E5\u53D1\u73B0 0 \u4E2A\u51B2\u7A81\u3002" : conflicts.map(
+    (conflict) => `## ${conflict.assetId}
+
+- \u8DEF\u5F84\uFF1A\`${conflict.path}\`
+- \u539F\u56E0\uFF1A${conflict.reason}
+- \u671F\u671B\u5185\u5BB9\u6307\u7EB9\uFF08hash\uFF09\uFF1A\`${conflict.expectedHash ?? "\u65E0"}\`
+- \u5F53\u524D\u5185\u5BB9\u6307\u7EB9\uFF08hash\uFF09\uFF1A\`${conflict.actualHash ?? "\u65E0"}\``
+  ).join("\n\n");
+  return (await loadTemplate("conflict-report.md")).replaceAll("{{run_id}}", runId).replaceAll("{{conflict_count}}", String(conflicts.length)).replaceAll("{{conflicts}}", details);
+}
+async function renderAcceptance(branch, base, head, result) {
+  const requirements = [
+    "| \u6761\u6B3E | \u7ED3\u679C |",
+    "|---|---|",
+    "| R1 \u8BC6\u522B\u8BFB\u53D6 | \u5DF2\u751F\u6210 manifest\uFF0C\u4ECD\u9700\u4EBA\u5DE5\u786E\u8BA4\u6750\u6599\u8303\u56F4 |",
+    "| R2 \u7ED3\u6784\u5316\u63D0\u53D6 | \u5DF2\u901A\u8FC7 JSON Schema |",
+    "| R3 \u56DB\u7EF4\u5206\u6790 | \u5DF2\u751F\u6210\u56DB\u7EF4\u57FA\u7EBF\uFF0C\u4E1A\u52A1\u7ED3\u8BBA\u9700\u4EBA\u5DE5\u62BD\u68C0 |",
+    "| R4 \u589E\u91CF\u56DE\u5199 | \u5DF2\u9650\u5236 docs/\u53EF\u8BFB\u5316 \u5E76\u8F93\u51FA\u51B2\u7A81\u62A5\u544A |",
+    "| R5 \u589E\u91CF\u72B6\u6001 | \u5DF2\u4FDD\u5B58\u6587\u4EF6 hash \u4E0E commit\uFF1B\u9700\u4E8C\u6B21\u8FD0\u884C\u9A8C\u8BC1 |",
+    "| R6 \u5168\u94FE\u8DEF\u7559\u75D5 | \u5DF2\u5EFA\u7ACB\u6765\u6E90\u3001revision\u3001asset \u4E0E\u8F93\u51FA\u6620\u5C04 |"
+  ].join("\n");
+  const verification = [
+    "| \u9A8C\u6536\u70B9 | \u7ED3\u679C |",
+    "|---|---|",
+    "| V1\u2013V4 | \u5DF2\u4EA7\u51FA\u673A\u5668\u8BC1\u636E\uFF1B\u771F\u5B9E\u6750\u6599\u4E0E\u56DB\u7EF4\u7ED3\u8BBA\u4ECD\u9700\u4EBA\u5DE5\u9A8C\u6536 |",
+    "| V5 | \u5DF2\u9A8C\u8BC1\u975E\u57FA\u7EBF\u5206\u652F\u4E0E Git scope\uFF1B\u63D0\u4EA4/PR \u5F85\u5916\u90E8\u6D41\u7A0B\u786E\u8BA4 |",
+    "| V6 | \u5F85\u76F8\u540C\u8F93\u5165\u4E8C\u6B21\u8FD0\u884C\u8BC1\u660E\u96F6\u4E1A\u52A1 diff |",
+    "| V7 | \u5DF2\u8BB0\u5F55 revision \u4E0E hash\uFF1B\u56DE\u5199 commit \u5F85\u63D0\u4EA4\u540E\u8865\u9F50 |",
+    "| V8 | \u5DF2\u751F\u6210\u7D22\u5F15\u4E0E\u8D44\u4EA7\u8BE6\u60C5\uFF1B\u53EF\u8BFB\u590D\u7528\u9700\u4EBA\u5DE5\u62BD\u68C0 |"
+  ].join("\n");
+  return (await loadTemplate("acceptance-report.md")).replaceAll("{{run_id}}", result.runId).replaceAll("{{branch}}", branch).replaceAll("{{base_sha}}", base).replaceAll("{{head_sha}}", head).replaceAll(
+    "{{source_type_summary}}",
+    [...new Set(result.assets.map((asset) => SOURCE_TYPE_LABEL[asset.sourceType]))].sort().join("\u3001")
+  ).replaceAll("{{new_count}}", String(result.counts.new)).replaceAll("{{updated_count}}", String(result.counts.updated)).replaceAll("{{unchanged_count}}", String(result.counts.unchanged)).replaceAll("{{conflict_count}}", String(result.counts.conflicts)).replaceAll("{{requirements_matrix}}", requirements).replaceAll("{{verification_matrix}}", verification).replaceAll(
+    "{{four_dimension_summary}}",
+    `${result.assets.length} \u6761\u8D44\u4EA7\u5747\u5305\u542B\u5B8C\u6574\u6027\u3001\u53EF\u6267\u884C\u6027\u3001\u4E00\u81F4\u6027\u3001\u590D\u7528\u4EF7\u503C\u56DB\u9879\u7ED3\u6784\u5316\u7ED3\u8BBA\u3002`
+  ).replaceAll(
+    "{{conflict_and_evidence_links}}",
+    `- [\u51B2\u7A81\u62A5\u544A](../conflicts/${result.runId}.md)
+- [\u6765\u6E90\u6E05\u5355](../source-manifest.yaml)`
+  );
+}
+async function render(repo, config, records, assets, previous) {
+  const head = await git(repo, ["rev-parse", "HEAD"]);
+  const branch = await git(repo, ["branch", "--show-current"]);
+  const baseBranch = config.baseBranch ?? "main";
+  const baseCommit = await git(repo, ["merge-base", "HEAD", baseBranch]);
+  const changedAssets = assets.filter((asset) => asset.writebackKind !== "\u672A\u53D8");
+  const conflicts = [];
+  const contentByAsset = /* @__PURE__ */ new Map();
+  for (const asset of assets) {
+    const content = renderAsset(asset);
+    contentByAsset.set(asset.assetId, content);
+    const old = previous?.assets[asset.assetId];
+    const expectedPath = `${OUTPUT_ROOT}/assets/${asset.assetId.slice(7)}.md`;
+    if (old) {
+      const oldPath = await assertOutputPath(repo, old.outputPath);
+      if (await exists(oldPath)) {
+        const actualHash = sha256(await readFile(oldPath, "utf8"));
+        if (actualHash !== old.lastGeneratedHash) {
+          conflicts.push({
+            assetId: asset.assetId,
+            path: old.outputPath,
+            reason: "\u4EBA\u5DE5\u7F16\u8F91\u4E0E\u751F\u6210\u5185\u5BB9\u51B2\u7A81\uFF0C\u5DF2\u62D2\u7EDD\u8986\u76D6",
+            expectedHash: old.lastGeneratedHash,
+            actualHash
+          });
+        }
+      } else {
+        conflicts.push({
+          assetId: asset.assetId,
+          path: old.outputPath,
+          reason: "state \u5F15\u7528\u7684\u751F\u6210\u6587\u4EF6\u7F3A\u5931\uFF0C\u5DF2\u62D2\u7EDD\u9759\u9ED8\u91CD\u5EFA",
+          expectedHash: old.lastGeneratedHash
+        });
+      }
+    } else if (await exists(path.join(repo, expectedPath))) {
+      conflicts.push({
+        assetId: asset.assetId,
+        path: expectedPath,
+        reason: "\u53D1\u73B0\u65E0 state \u5F52\u5C5E\u7684\u65E2\u6709\u8D44\u4EA7\u6587\u4EF6\uFF0C\u5DF2\u62D2\u7EDD\u8986\u76D6",
+        actualHash: sha256(await readFile(path.join(repo, expectedPath), "utf8"))
+      });
+    }
+  }
+  for (const [managedPath, expectedHash] of Object.entries(previous?.managedFiles ?? {})) {
+    const absolute = await assertOutputPath(repo, managedPath);
+    if (!await exists(absolute)) {
+      conflicts.push({
+        assetId: `managed:${managedPath}`,
+        path: managedPath,
+        reason: "\u53D7\u7BA1\u8F93\u51FA\u6587\u4EF6\u7F3A\u5931\uFF0C\u5DF2\u62D2\u7EDD\u9759\u9ED8\u91CD\u5EFA",
+        expectedHash
+      });
+      continue;
+    }
+    const actualHash = sha256(await readFile(absolute));
+    if (actualHash !== expectedHash) {
+      conflicts.push({
+        assetId: `managed:${managedPath}`,
+        path: managedPath,
+        reason: "\u53D7\u7BA1\u8F93\u51FA\u88AB\u4EBA\u5DE5\u7F16\u8F91\uFF0C\u5DF2\u62D2\u7EDD\u8986\u76D6",
+        expectedHash,
+        actualHash
+      });
+    }
+  }
+  const runId = sha256(
+    `${head}
+${records.map((record) => `${record.sourceRef}:${record.contentHash}`).join("\n")}`
+  ).slice(7, 23);
+  if (!previous) {
+    const firstRunManagedPaths = [
+      `${OUTPUT_ROOT}/README.md`,
+      `${OUTPUT_ROOT}/index.md`,
+      `${OUTPUT_ROOT}/source-manifest.yaml`,
+      `${OUTPUT_ROOT}/conflicts/${runId}.md`,
+      `${OUTPUT_ROOT}/evidence/acceptance-report.md`,
+      `${OUTPUT_ROOT}/runs/${runId}.md`,
+      `${OUTPUT_ROOT}/state/asset-index.jsonl`
+    ];
+    for (const managedPath of firstRunManagedPaths) {
+      const absolute = await assertOutputPath(repo, managedPath);
+      if (await exists(absolute)) {
+        conflicts.push({
+          assetId: `managed:${managedPath}`,
+          path: managedPath,
+          reason: "\u9996\u6B21\u8FD0\u884C\u53D1\u73B0\u65E0 state \u5F52\u5C5E\u7684\u65E2\u6709\u53D7\u7BA1\u6587\u4EF6\uFF0C\u5DF2\u62D2\u7EDD\u8986\u76D6",
+          actualHash: sha256(await readFile(absolute))
+        });
+      }
+    }
+  }
+  const conflictIds = new Set(conflicts.map((conflict) => conflict.assetId));
+  const writableAssets = changedAssets.filter((asset) => !conflictIds.has(asset.assetId));
+  const currentSourceKeys = new Set(
+    records.map((record) => `${record.sourceType}:${record.sourceRef}`)
+  );
+  const hasStaleTransition = Object.entries(previous?.sources ?? {}).some(
+    ([key, value]) => value.status === "active" && !currentSourceKeys.has(key)
+  );
+  const resultBase = {
+    runId,
+    counts: {
+      new: assets.filter((asset) => asset.writebackKind === "\u65B0\u589E").length,
+      updated: assets.filter((asset) => asset.writebackKind === "\u589E\u91CF").length,
+      unchanged: assets.filter((asset) => asset.writebackKind === "\u672A\u53D8").length,
+      conflicts: conflicts.length
+    },
+    assets,
+    conflicts,
+    noOp: changedAssets.length === 0 && conflicts.length === 0 && !hasStaleTransition
+  };
+  if (resultBase.noOp) {
+    return { ...resultBase, changedFiles: [], secondRunZeroDiff: true };
+  }
+  if (conflicts.length > 0) {
+    const conflictKey = sha256(JSON.stringify(conflicts)).slice(7, 19);
+    const conflictPath = `${OUTPUT_ROOT}/conflicts/${runId}-${conflictKey}.md`;
+    const changed = await atomicWriteIfChanged(
+      repo,
+      conflictPath,
+      await renderConflicts(runId, conflicts)
+    );
+    return {
+      ...resultBase,
+      changedFiles: changed ? [conflictPath] : []
+    };
+  }
+  const changedFiles = [];
+  const write = async (file, content) => {
+    if (await atomicWriteIfChanged(repo, file, content)) changedFiles.push(file);
+  };
+  for (const asset of writableAssets) {
+    const file = `${OUTPUT_ROOT}/assets/${asset.assetId.slice(7)}.md`;
+    await write(file, contentByAsset.get(asset.assetId) ?? renderAsset(asset));
+  }
+  const sources = {};
+  for (const [key, value] of Object.entries(previous?.sources ?? {})) {
+    sources[key] = { ...value, status: "stale" };
+  }
+  for (const record of records) {
+    const sourceKey = `${record.sourceType}:${record.sourceRef}`;
+    const asset = assets.find(
+      (candidate) => candidate.sourceType === record.sourceType && candidate.sourceRef === record.sourceRef
+    );
+    if (!asset || conflictIds.has(asset.assetId)) continue;
+    sources[sourceKey] = {
+      contentHash: record.contentHash,
+      sourceRevision: record.sourceRevision,
+      assetIds: [asset.assetId],
+      status: "active"
+    };
+  }
+  const stateAssets = { ...previous?.assets ?? {} };
+  for (const asset of writableAssets) {
+    const outputPath = `${OUTPUT_ROOT}/assets/${asset.assetId.slice(7)}.md`;
+    const content = contentByAsset.get(asset.assetId) ?? renderAsset(asset);
+    stateAssets[asset.assetId] = {
+      canonicalContentHash: asset.contentHash,
+      outputPath,
+      lastGeneratedHash: sha256(`${content.trimEnd()}
+`)
+    };
+  }
+  const manifest = {
+    sourceTypes: [...new Set(records.map((record) => record.sourceType))].sort(),
+    sources: records.map(({ content: _content, ...record }) => record)
+  };
+  const managedContents = {
+    [`${OUTPUT_ROOT}/README.md`]: "# \u53EF\u8BFB\u5316\u8D44\u4EA7\n\n\u4ECE `index.md` \u5F00\u59CB\u9605\u8BFB\u3002\u6240\u6709\u5185\u5BB9\u5747\u4FDD\u7559\u6765\u6E90\u548C\u6765\u6E90\u7248\u672C\uFF08revision\uFF09\u3002\n",
+    [`${OUTPUT_ROOT}/index.md`]: renderIndex(assets),
+    [`${OUTPUT_ROOT}/source-manifest.yaml`]: stringifyYaml(manifest),
+    [`${OUTPUT_ROOT}/conflicts/${runId}.md`]: await renderConflicts(runId, conflicts),
+    [`${OUTPUT_ROOT}/evidence/acceptance-report.md`]: await renderAcceptance(
+      branch,
+      baseCommit,
+      head,
+      resultBase
+    ),
+    [`${OUTPUT_ROOT}/runs/${runId}.md`]: `# \u8FD0\u884C\u8BB0\u5F55 ${runId}
+
+- \u5F53\u524D\u63D0\u4EA4\uFF1A\`${head}\`
+- \u6765\u6E90\u6570\uFF1A${records.length}
+- \u65B0\u589E\uFF1A${resultBase.counts.new}
+- \u589E\u91CF\uFF1A${resultBase.counts.updated}
+- \u672A\u53D8\uFF1A${resultBase.counts.unchanged}
+- \u51B2\u7A81\uFF1A${conflicts.length}
+`,
+    [`${OUTPUT_ROOT}/state/asset-index.jsonl`]: `${assets.map((asset) => JSON.stringify(asset)).join("\n")}
+`
+  };
+  const managedFiles = {
+    ...previous?.managedFiles ?? {},
+    ...Object.fromEntries(
+      Object.entries(managedContents).map(([file, content]) => [
+        file,
+        sha256(`${content.trimEnd()}
+`)
+      ])
+    )
+  };
+  const nextState = {
+    schemaVersion: 1,
+    selfHash: "",
+    baseBranch,
+    baseCommit: previous?.baseCommit ?? baseCommit,
+    lastReadCommit: head,
+    sources,
+    assets: stateAssets,
+    managedFiles
+  };
+  nextState.selfHash = sha256(JSON.stringify({ ...nextState, selfHash: "" }, null, 2));
+  assertValid(validateState, nextState, "\u4E0B\u4E00\u7248\u72B6\u6001");
+  for (const [file, content] of Object.entries(managedContents)) {
+    await write(file, content);
+  }
+  await write(`${OUTPUT_ROOT}/state/read-state.json`, JSON.stringify(nextState, null, 2));
+  changedFiles.sort();
+  return { ...resultBase, changedFiles };
+}
+async function verifyGitScope(repo) {
+  const output = await git(repo, ["status", "--porcelain=v1", "-z", "--untracked-files=all"]);
+  const entries = output.split("\0").filter(Boolean);
+  const paths = [];
+  for (let index = 0; index < entries.length; index += 1) {
+    const entry = entries[index] ?? "";
+    paths.push(entry.slice(3));
+    const status = entry.slice(0, 2);
+    if (status.includes("R") || status.includes("C")) {
+      const original = entries[index + 1];
+      if (original) paths.push(original);
+      index += 1;
+    }
+  }
+  const outside = paths.filter(
+    (file) => file !== OUTPUT_ROOT && !file.startsWith(`${OUTPUT_ROOT}/`)
+  );
+  if (outside.length) {
+    throw new Error(`\u68C0\u6D4B\u5230 ${OUTPUT_ROOT} \u4E4B\u5916\u7684\u6539\u52A8\uFF1A${outside.join("\u3001")}`);
+  }
+  return paths.sort();
+}
+async function runPipeline(repoInput, configPath, assetsFile) {
+  const repo = await realpath(repoInput);
+  const config = await loadConfig(configPath);
+  const branch = await git(repo, ["branch", "--show-current"]);
+  const baseBranch = config.baseBranch ?? "main";
+  if (!branch || branch === baseBranch) {
+    throw new Error(`\u5199\u5165\u5FC5\u987B\u4F7F\u7528\u72EC\u7ACB\u5206\u652F\uFF1B\u5F53\u524D\u5206\u652F\u4E3A ${branch || "\uFF08\u5206\u79BB HEAD\uFF09"}`);
+  }
+  await verifyGitScope(repo);
+  const previous = await readState(repo);
+  const records = await scan(repo, config);
+  const baselineAssets = prepare(records, previous);
+  const assets = assetsFile ? (await loadAssetsFile(assetsFile, records)).map((asset) => ({
+    ...asset,
+    writebackKind: baselineAssets.find((baseline) => baseline.assetId === asset.assetId)?.writebackKind ?? asset.writebackKind
+  })) : baselineAssets;
+  const result = await render(repo, config, records, assets, previous);
+  await verifyGitScope(repo);
+  return result;
+}
+async function inspectPipeline(repoInput, configPath) {
+  const repo = await realpath(repoInput);
+  const config = await loadConfig(configPath);
+  const previous = await readState(repo);
+  const records = await scan(repo, config);
+  return { records, assets: prepare(records, previous) };
+}
+async function verifySecondRun(repoInput, configPath) {
+  const repo = await realpath(repoInput);
+  const config = await loadConfig(configPath);
+  const previous = await readState(repo);
+  if (!previous) throw new Error("\u4E8C\u6B21\u8FD0\u884C\u9A8C\u8BC1\u9700\u8981\u5DF2\u6709 state");
+  const records = await scan(repo, config);
+  const assets = prepare(records, previous);
+  const changed = assets.filter((asset) => asset.writebackKind !== "\u672A\u53D8");
+  if (changed.length) {
+    throw new Error(`\u7B2C\u4E8C\u6B21\u8FD0\u884C\u4ECD\u6709 ${changed.length} \u6761\u65B0\u589E\u6216\u589E\u91CF\u8D44\u4EA7`);
+  }
+  for (const asset of assets) {
+    const state = previous.assets[asset.assetId];
+    if (!state) throw new Error(`\u7F3A\u5C11\u8D44\u4EA7\u72B6\u6001\uFF1A${asset.assetId}`);
+    const target = await assertOutputPath(repo, state.outputPath);
+    if (!await exists(target) || sha256(await readFile(target)) !== state.lastGeneratedHash) {
+      throw new Error(`\u751F\u6210\u8D44\u4EA7\u4E0E state \u4E0D\u4E00\u81F4\uFF1A${state.outputPath}`);
+    }
+  }
+  for (const [managedPath, expectedHash] of Object.entries(previous.managedFiles)) {
+    const target = await assertOutputPath(repo, managedPath);
+    if (!await exists(target) || sha256(await readFile(target)) !== expectedHash) {
+      throw new Error(`\u53D7\u7BA1\u8F93\u51FA\u4E0E state \u4E0D\u4E00\u81F4\uFF1A${managedPath}`);
+    }
+  }
+  await verifyGitScope(repo);
+  return {
+    secondRunZeroDiff: true,
+    counts: { new: 0, updated: 0, unchanged: assets.length, conflicts: 0 },
+    stateCommit: previous.lastReadCommit
+  };
+}
+
+// src/setup.ts
+import { mkdir as mkdir2, readFile as readFile2, stat } from "fs/promises";
+import os from "os";
+import path2 from "path";
+import writeFileAtomic2 from "write-file-atomic";
+var PACKAGE_ROOT = new URL("../", import.meta.url);
+async function exists2(target) {
+  try {
+    await stat(target);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function packageText(relativePath) {
+  return readFile2(new URL(relativePath, PACKAGE_ROOT), "utf8");
+}
+async function writeGenerated(target, content, force) {
+  if (!force && await exists2(target)) {
+    throw new Error(`\u76EE\u6807\u6587\u4EF6\u5DF2\u5B58\u5728\uFF1B\u5982\u9700\u8986\u76D6\u8BF7\u4F7F\u7528 --force\uFF1A${target}`);
+  }
+  await mkdir2(path2.dirname(target), { recursive: true });
+  await writeFileAtomic2(target, `${content.trimEnd()}
+`, {
+    encoding: "utf8",
+    fsync: true
+  });
+}
+async function initGenericWorkspace(options = {}) {
+  const outputDir = path2.resolve(
+    options.output ?? path2.join(os.homedir(), ".asset-compound")
+  );
+  const baseBranch = options.baseBranch ?? "main";
+  const files = {
+    readme: path2.join(outputDir, "README.md"),
+    config: path2.join(outputDir, "run.yaml"),
+    prompt: path2.join(outputDir, "prompts", "asset-analysis.zh-CN.md"),
+    protocol: path2.join(outputDir, "protocol", "README.zh-CN.md"),
+    inputSchema: path2.join(outputDir, "schemas", "analysis-input.schema.json"),
+    outputSchema: path2.join(outputDir, "schemas", "analysis-output.schema.json")
+  };
+  const config = `outputRoot: docs/\u53EF\u8BFB\u5316
+baseBranch: ${baseBranch}
+sourceSets:
+  - type: requirement
+    include:
+      - docs/requirements/**/*.md
+  - type: design
+    include:
+      - docs/design/**/*.md
+exclude:
+  - node_modules/**
+  - dist/**
+  - build/**
+  - coverage/**
+`;
+  const readme = `# \u8D44\u4EA7\u590D\u5229\u901A\u7528\u5DE5\u4F5C\u533A
+
+\u672C\u76EE\u5F55\u7531 \`asset-compound init\` \u751F\u6210\uFF0C\u4E0D\u4F9D\u8D56\u7279\u5B9A\u7F16\u8F91\u5668\u3002
+
+1. \u4FEE\u6539 \`run.yaml\`\uFF0C\u4F7F\u7528\u81F3\u5C11\u4E24\u7C7B\u771F\u5B9E\u975E\u7A7A\u6765\u6E90\u3002
+2. \u6267\u884C \`npx @vinsonw2/asset-compound prepare --repo <\u4ED3\u5E93> --config "${files.config}" > prepared.json\`\u3002
+3. \u8BA9\u4EFB\u610F AI \u7F16\u8F91\u5668\u6309 \`prompts/asset-analysis.zh-CN.md\` \u548C \`protocol/README.zh-CN.md\` \u751F\u6210 \`enriched.json\`\u3002
+4. \u6267\u884C \`npx @vinsonw2/asset-compound validate --input enriched.json\`\u3002
+5. \u5728\u72EC\u7ACB\u5206\u652F\u6267\u884C \`npx @vinsonw2/asset-compound finalize --repo <\u4ED3\u5E93> --config "${files.config}" --assets enriched.json\`\u3002
+
+\u547D\u4EE4\u540D\u3001JSON \u5B57\u6BB5\u548C\u679A\u4E3E\u4FDD\u6301\u82F1\u6587\uFF1B\u4E2D\u6587\u542B\u4E49\u89C1\u63D0\u793A\u534F\u8BAE\u3002
+`;
+  const force = options.force ?? false;
+  await writeGenerated(files.readme, readme, force);
+  await writeGenerated(files.config, config, force);
+  await writeGenerated(
+    files.prompt,
+    await packageText("prompts/asset-analysis.zh-CN.md"),
+    force
+  );
+  await writeGenerated(
+    files.protocol,
+    await packageText("protocol/README.zh-CN.md"),
+    force
+  );
+  await writeGenerated(
+    files.inputSchema,
+    await packageText("schemas/analysis-input.schema.json"),
+    force
+  );
+  await writeGenerated(
+    files.outputSchema,
+    await packageText("schemas/analysis-output.schema.json"),
+    force
+  );
+  return {
+    mode: "generic",
+    outputDir,
+    ...files
+  };
+}
+async function installEditorSkill(options) {
+  if (options.editor !== "cursor") {
+    throw new Error(
+      `\u5F53\u524D\u4EC5\u63D0\u4F9B Cursor \u9002\u914D\u5668\uFF1B\u901A\u7528\u6A21\u5F0F\u8BF7\u4F7F\u7528 init\u3002\u6536\u5230 editor=${options.editor}`
+    );
+  }
+  const target = path2.resolve(
+    options.target ?? path2.join(os.homedir(), ".cursor", "skills", "asset-compounding")
+  );
+  const skillFile = path2.join(target, "SKILL.md");
+  await writeGenerated(
+    skillFile,
+    await packageText("skill/asset-compounding/SKILL.md"),
+    options.force ?? false
+  );
+  return {
+    editor: "cursor",
+    target,
+    skillFile
+  };
+}
+
+export {
+  assetSchema,
+  validateAsset,
+  validateConfig,
+  validateState,
+  assertValid,
+  sha256,
+  git,
+  assertOutputPath,
+  atomicWriteIfChanged,
+  loadConfig,
+  plan,
+  scan,
+  redactSensitive,
+  prepare,
+  loadAssetsFile,
+  renderAsset,
+  render,
+  verifyGitScope,
+  runPipeline,
+  inspectPipeline,
+  verifySecondRun,
+  initGenericWorkspace,
+  installEditorSkill
+};
+//# sourceMappingURL=chunk-P2MVWNYS.js.map