@haiyangbg/buildbeat 2.0.2 → 3.0.1

package/src/v2/presets/risk/legacy-four-gates.yaml

@@ -1,44 +0,0 @@
-# Migration preset mapping BuildBeat v1's four fixed gates:
-#   Gate1 (requirements) -> intent acceptance (digest-bound)
-#   Gate2 (design)       -> plan acceptance + human boundary before build
-#   Gate3 (merge)        -> the built-in final merge decision
-#   Gate4 (release)      -> out of MVP scope (no deploy capability exists)
-# The extra human boundary before review preserves v1's late review gate.
-kind: risk-preset
-version: 1
-name: legacy-four-gates
-stopAt:
-  - build
-  - review
-policies:
-  - kind: policy
-    version: 1
-    name: intent-accepted
-    type: pre
-    appliesTo: build
-    enforcement: LOCAL_ENFORCED
-    rule:
-      artifact.accepted:
-        artifact: intent
-  - kind: policy
-    version: 1
-    name: plan-accepted
-    type: pre
-    appliesTo: build
-    enforcement: LOCAL_ENFORCED
-    rule:
-      artifact.accepted:
-        artifact: plan
-  - kind: policy
-    version: 1
-    name: merge-evidence-floor
-    type: transition
-    appliesTo: enter-wait-merge
-    enforcement: LOCAL_ENFORCED
-    rule:
-      all:
-        - evidence.exists:
-            kind: command
-            minGrade: L2
-        - finding.maxSeverity:
-            atMost: P2

package/src/writer.js

@@ -1,534 +0,0 @@
-import { createHash } from "node:crypto";
-import {
-  chmodSync,
-  closeSync,
-  existsSync,
-  fsyncSync,
-  lstatSync,
-  mkdirSync,
-  openSync,
-  readFileSync,
-  renameSync,
-  rmdirSync,
-  unlinkSync,
-  writeFileSync,
-} from "node:fs";
-import path from "node:path";
-import { fileURLToPath } from "node:url";
-
-import {
-  CLI_VERSION,
-  FILE_POLICIES,
-  GITIGNORE_BEGIN_MARKER,
-  GITIGNORE_END_MARKER,
-  GITIGNORE_MARKER_PAIRS,
-  MANIFEST_PATH,
-  MANIFEST_SCHEMA_VERSION,
-  RENDER_REQUIRED_PLACEHOLDERS,
-  SCAFFOLD_VERSION,
-} from "./constants.js";
-import { inspectProject, plannedFiles } from "./project.js";
-
-const TEMPLATE_ROOT = fileURLToPath(new URL("../templates/", import.meta.url));
-const COMPACT_SCRIPT_REFERENCE_TEMPLATES = new Set([
-  "AGENTS.md",
-  "ARCHITECTURE.md",
-  "contracts/PROTOCOL.md",
-  "pm/NOW.md",
-  "pm/status/README.md",
-  "pm/当期看板.md",
-  "指挥台.md",
-]);
-
-export class WriteError extends Error {
-  constructor(code, message, cause = null) {
-    super(message, cause ? { cause } : undefined);
-    this.name = "WriteError";
-    this.code = code;
-  }
-}
-
-function sha256(bytes) {
-  return createHash("sha256").update(bytes).digest("hex");
-}
-
-function replaceAll(text, token, value) {
-  return text.split(token).join(value);
-}
-
-function stableDate(now) {
-  const value = now instanceof Date ? now : new Date(now);
-  if (Number.isNaN(value.getTime())) {
-    throw new WriteError("render.invalid_date", "The scaffold render date is invalid.");
-  }
-  return value;
-}
-
-function localCalendarDate(now) {
-  const value = stableDate(now);
-  const year = String(value.getFullYear()).padStart(4, "0");
-  const month = String(value.getMonth() + 1).padStart(2, "0");
-  const day = String(value.getDate()).padStart(2, "0");
-  return `${year}-${month}-${day}`;
-}
-
-function deterministicValues({ layout, projectName, now }) {
-  return new Map([
-    ["<项目名>", projectName || "project"],
-    ["<yyyy-mm-dd>", localCalendarDate(now)],
-    ["<X.Y>", SCAFFOLD_VERSION.replace(/^v/, "")],
-    ["<默认|紧凑>", layout === "compact" ? "紧凑" : "默认"],
-  ]);
-}
-
-function ownedGitignoreFragment(body) {
-  const normalizedBody = body.replace(/\r\n/g, "\n").replace(/\n*$/, "");
-  return Buffer.from(
-    `${GITIGNORE_BEGIN_MARKER}\n${normalizedBody}\n${GITIGNORE_END_MARKER}\n`,
-    "utf8",
-  );
-}
-
-export function prepareScaffold({ layout, projectName, now = new Date() }) {
-  const values = deterministicValues({ layout, projectName, now });
-  const files = [];
-  const renderedPlaceholders = [];
-  const pendingPlaceholders = [];
-  let gitignore = null;
-
-  for (const item of plannedFiles(layout)) {
-    const source = path.join(TEMPLATE_ROOT, item.template);
-    let text = readFileSync(source, "utf8");
-    for (const [token, value] of values) {
-      if (text.includes(token)) {
-        text = replaceAll(text, token, value);
-        renderedPlaceholders.push({ path: item.target, token, value });
-      }
-    }
-    if (
-      layout === "compact" &&
-      COMPACT_SCRIPT_REFERENCE_TEMPLATES.has(item.template) &&
-      text.includes("scripts/")
-    ) {
-      text = replaceAll(text, "scripts/", "pm/scripts/");
-      renderedPlaceholders.push({
-        path: item.target,
-        token: "scripts/",
-        value: "pm/scripts/",
-      });
-    }
-
-    const pendingTokens = (RENDER_REQUIRED_PLACEHOLDERS[item.template] || [])
-      .filter((token) => text.includes(token));
-    if (pendingTokens.length > 0) {
-      pendingPlaceholders.push({ path: item.target, tokens: pendingTokens });
-    }
-
-    const mode = lstatSync(source).mode & 0o777;
-    if (item.policy === FILE_POLICIES.MERGE_ONLY) {
-      const fragment = ownedGitignoreFragment(text);
-      gitignore = {
-        ...item,
-        fragment,
-        baselineSha256: sha256(fragment),
-        mode,
-      };
-    } else {
-      const content = Buffer.from(text, "utf8");
-      files.push({
-        ...item,
-        content,
-        baselineSha256: sha256(content),
-        mode,
-      });
-    }
-  }
-
-  renderedPlaceholders.sort((a, b) =>
-    a.path.localeCompare(b.path) || a.token.localeCompare(b.token),
-  );
-  pendingPlaceholders.sort((a, b) => a.path.localeCompare(b.path));
-  if (gitignore === null) {
-    throw new WriteError("integration.gitignore_missing", "The bundled gitignore template is missing.");
-  }
-  return { files, gitignore, renderedPlaceholders, pendingPlaceholders };
-}
-
-function ensureDirectory(directory, createdDirectories) {
-  if (existsSync(directory)) {
-    const stat = lstatSync(directory);
-    if (!stat.isDirectory() || stat.isSymbolicLink()) {
-      throw new WriteError("path.unsafe", `A required directory path is not a real directory: ${directory}`);
-    }
-    return;
-  }
-  const parent = path.dirname(directory);
-  if (parent === directory) {
-    throw new WriteError("path.unsafe", `Cannot create target directory: ${directory}`);
-  }
-  ensureDirectory(parent, createdDirectories);
-  try {
-    mkdirSync(directory, { mode: 0o755 });
-    createdDirectories.push(directory);
-  } catch (error) {
-    if (error.code === "EEXIST") {
-      ensureDirectory(directory, createdDirectories);
-      return;
-    }
-    throw error;
-  }
-}
-
-function assertRelativeTarget(relative) {
-  if (
-    typeof relative !== "string" ||
-    relative.length === 0 ||
-    relative.includes("\\") ||
-    path.posix.isAbsolute(relative) ||
-    path.win32.isAbsolute(relative) ||
-    path.posix.normalize(relative) !== relative ||
-    relative.split("/").some((segment) => segment === "" || segment === "." || segment === "..")
-  ) {
-    throw new WriteError("path.unsafe", `Unsafe scaffold target path: ${relative}`);
-  }
-}
-
-function ensureTargetParent(target, relative, createdDirectories) {
-  assertRelativeTarget(relative);
-  ensureDirectory(path.dirname(path.join(target, ...relative.split("/"))), createdDirectories);
-}
-
-function fsyncDirectory(directory) {
-  if (process.platform === "win32") {
-    return;
-  }
-  const descriptor = openSync(directory, "r");
-  try {
-    fsyncSync(descriptor);
-  } finally {
-    closeSync(descriptor);
-  }
-}
-
-function atomicWrite(
-  filename,
-  bytes,
-  mode,
-  { overwrite = false, nextTempId, onRenamed = null },
-) {
-  const parent = path.dirname(filename);
-  const basename = path.basename(filename);
-  let temp = null;
-  let descriptor = null;
-  try {
-    for (let attempt = 0; attempt < 100; attempt += 1) {
-      const candidate = path.join(
-        parent,
-        `.${basename}.buildbeat-${process.pid}-${nextTempId()}-${attempt}.tmp`,
-      );
-      try {
-        descriptor = openSync(candidate, "wx", mode);
-        temp = candidate;
-        break;
-      } catch (error) {
-        if (error.code !== "EEXIST") {
-          throw error;
-        }
-      }
-    }
-    if (descriptor === null || temp === null) {
-      throw new WriteError("write.temp_unavailable", `Could not allocate a temporary sibling for ${filename}.`);
-    }
-    writeFileSync(descriptor, bytes);
-    fsyncSync(descriptor);
-    closeSync(descriptor);
-    descriptor = null;
-    chmodSync(temp, mode);
-
-    if (!overwrite && existsSync(filename)) {
-      throw new WriteError("files.collide", `Destination appeared during the write transaction: ${filename}`);
-    }
-    if (overwrite) {
-      const current = lstatSync(filename);
-      if (!current.isFile() || current.isSymbolicLink()) {
-        throw new WriteError("integration.gitignore_unsafe", ".gitignore is no longer a regular file.");
-      }
-    }
-    renameSync(temp, filename);
-    temp = null;
-    if (typeof onRenamed === "function") {
-      onRenamed();
-    }
-    fsyncDirectory(parent);
-  } finally {
-    if (descriptor !== null) {
-      closeSync(descriptor);
-    }
-    if (temp !== null) {
-      try {
-        unlinkSync(temp);
-      } catch (error) {
-        if (error.code !== "ENOENT") {
-          throw error;
-        }
-      }
-    }
-  }
-}
-
-function markerCount(text, marker) {
-  return text.split(marker).length - 1;
-}
-
-function assertGitignoreBytesSafe(bytes) {
-  const text = bytes.toString("utf8");
-  if (GITIGNORE_MARKER_PAIRS.some(
-    ([beginMarker, endMarker]) =>
-      markerCount(text, beginMarker) !== 0 || markerCount(text, endMarker) !== 0,
-  )) {
-    throw new WriteError(
-      "integration.gitignore_fragment_present",
-      "A BuildBeat or legacy Solobaton .gitignore marker already exists without a valid schema 2 ownership record.",
-    );
-  }
-}
-
-function mergeGitignore(existing, fragment) {
-  if (existing.length === 0) {
-    return fragment;
-  }
-  const separator = existing.at(-1) === 0x0a ? Buffer.from("\n") : Buffer.from("\n\n");
-  return Buffer.concat([existing, separator, fragment]);
-}
-
-function preflight(plan) {
-  if (plan.preview || plan.writesPerformed || !["init", "adopt"].includes(plan.command)) {
-    throw new WriteError("write.invalid_plan", "Only a ready init/adopt apply plan can be written.");
-  }
-  let inspection;
-  try {
-    inspection = inspectProject(plan.target, {
-      collisionLayout: plan.layout,
-      includeDependencies: false,
-    });
-  } catch (error) {
-    throw new WriteError("target.unsafe", error.message, error);
-  }
-  if (plan.command === "adopt" && !inspection.exists) {
-    throw new WriteError("target.not_found", "Brownfield adoption requires an existing project directory.");
-  }
-  if (inspection.installation.state !== "not-installed") {
-    throw new WriteError(
-      `install.${inspection.installation.state.replaceAll("-", "_")}`,
-      "The target is already installed, partial, or mixed; no write was attempted.",
-    );
-  }
-  if (inspection.manifest.state !== "missing") {
-    throw new WriteError(
-      "manifest.already_present",
-      "A lifecycle manifest already exists or is unreadable; ownership cannot be inferred.",
-    );
-  }
-  if (inspection.collisions.length > 0) {
-    throw new WriteError(
-      "files.collide",
-      `${inspection.collisions.length} destination path(s) collide with existing project content.`,
-    );
-  }
-  if (inspection.gitWorktree.state === "dirty") {
-    throw new WriteError("git.dirty", "The target-root Git worktree is not clean.");
-  }
-  if (inspection.gitWorktree.state === "unavailable") {
-    throw new WriteError("git.status_unavailable", "The target has a root .git entry, but Git status failed.");
-  }
-  if (inspection.gitignore.state === "unsafe") {
-    throw new WriteError("integration.gitignore_unsafe", ".gitignore is not a readable regular file.");
-  }
-  if (inspection.gitignore.beginMarkers > 0 || inspection.gitignore.endMarkers > 0) {
-    throw new WriteError(
-      "integration.gitignore_fragment_present",
-      "A BuildBeat or legacy Solobaton .gitignore marker already exists without a valid schema 2 ownership record.",
-    );
-  }
-  return inspection;
-}
-
-function rollback({ createdFiles, createdDirectories, gitignoreBackup, gitignoreModified, nextTempId }) {
-  const failures = [];
-  for (const filename of [...createdFiles].reverse()) {
-    try {
-      unlinkSync(filename);
-    } catch (error) {
-      if (error.code !== "ENOENT") {
-        failures.push(`${filename}: ${error.code || error.message}`);
-      }
-    }
-  }
-  if (gitignoreModified && gitignoreBackup !== null) {
-    try {
-      atomicWrite(
-        gitignoreBackup.path,
-        gitignoreBackup.bytes,
-        gitignoreBackup.mode,
-        { overwrite: true, nextTempId },
-      );
-    } catch (error) {
-      failures.push(`${gitignoreBackup.path}: ${error.code || error.message}`);
-    }
-  }
-  for (const directory of [...createdDirectories].reverse()) {
-    try {
-      rmdirSync(directory);
-    } catch (error) {
-      if (error.code !== "ENOENT" && error.code !== "ENOTEMPTY") {
-        failures.push(`${directory}: ${error.code || error.message}`);
-      }
-    }
-  }
-  return failures;
-}
-
-export function applyScaffold(plan, { now = new Date(), faultInjector = null } = {}) {
-  const inspection = preflight(plan);
-  const rendered = prepareScaffold({
-    layout: plan.layout,
-    projectName: inspection.projectName.value,
-    now,
-  });
-  const target = path.resolve(plan.target);
-  const createdFiles = [];
-  const createdDirectories = [];
-  let gitignoreBackup = null;
-  let gitignoreModified = false;
-  let tempId = 0;
-  const nextTempId = () => {
-    tempId += 1;
-    return tempId;
-  };
-  const maybeFault = (phase, relative) => {
-    if (typeof faultInjector === "function") {
-      faultInjector({ phase, path: relative, writes: createdFiles.length });
-    }
-  };
-
-  try {
-    ensureDirectory(target, createdDirectories);
-
-    for (const item of rendered.files) {
-      ensureTargetParent(target, item.target, createdDirectories);
-      const filename = path.join(target, ...item.target.split("/"));
-      atomicWrite(filename, item.content, item.mode, {
-        nextTempId,
-        onRenamed: () => createdFiles.push(filename),
-      });
-      maybeFault("file", item.target);
-    }
-
-    const gitignorePath = path.join(target, ".gitignore");
-    ensureTargetParent(target, ".gitignore", createdDirectories);
-    let existingGitignore = Buffer.alloc(0);
-    let gitignoreMode = rendered.gitignore.mode || 0o644;
-    const gitignoreExisted = existsSync(gitignorePath);
-    if (gitignoreExisted) {
-      const stat = lstatSync(gitignorePath);
-      if (!stat.isFile() || stat.isSymbolicLink()) {
-        throw new WriteError("integration.gitignore_unsafe", ".gitignore is not a regular file.");
-      }
-      existingGitignore = readFileSync(gitignorePath);
-      assertGitignoreBytesSafe(existingGitignore);
-      gitignoreMode = stat.mode & 0o777;
-      gitignoreBackup = { path: gitignorePath, bytes: existingGitignore, mode: gitignoreMode };
-    }
-    atomicWrite(
-      gitignorePath,
-      mergeGitignore(existingGitignore, rendered.gitignore.fragment),
-      gitignoreMode,
-      {
-        overwrite: gitignoreExisted,
-        nextTempId,
-        onRenamed: () => {
-          if (gitignoreExisted) {
-            gitignoreModified = true;
-          } else {
-            createdFiles.push(gitignorePath);
-          }
-        },
-      },
-    );
-    maybeFault("gitignore", ".gitignore");
-
-    const manifest = {
-      schemaVersion: MANIFEST_SCHEMA_VERSION,
-      scaffoldVersion: SCAFFOLD_VERSION,
-      cliVersion: CLI_VERSION,
-      layout: plan.layout,
-      installedAt: stableDate(now).toISOString(),
-      files: Object.fromEntries(
-        rendered.files.map((item) => [
-          item.target,
-          { policy: item.policy, baselineSha256: item.baselineSha256 },
-        ]),
-      ),
-      integrations: {
-        gitignore: {
-          path: ".gitignore",
-          beginMarker: GITIGNORE_BEGIN_MARKER,
-          endMarker: GITIGNORE_END_MARKER,
-          baselineSha256: rendered.gitignore.baselineSha256,
-        },
-        hooks: null,
-      },
-    };
-    ensureTargetParent(target, MANIFEST_PATH, createdDirectories);
-    maybeFault("before-manifest", MANIFEST_PATH);
-    const manifestFilename = path.join(target, ...MANIFEST_PATH.split("/"));
-    atomicWrite(
-      manifestFilename,
-      Buffer.from(`${JSON.stringify(manifest, null, 2)}\n`, "utf8"),
-      0o644,
-      {
-        nextTempId,
-        onRenamed: () => createdFiles.push(manifestFilename),
-      },
-    );
-
-    return {
-      ...plan,
-      preview: false,
-      writesPerformed: true,
-      targetExists: true,
-      detected: {
-        ...plan.detected,
-        projectName: inspection.projectName,
-      },
-      writtenPaths: [
-        ...rendered.files.map((item) => item.target),
-        ".gitignore",
-        MANIFEST_PATH,
-      ],
-      renderedPlaceholders: rendered.renderedPlaceholders,
-      pendingPlaceholders: rendered.pendingPlaceholders,
-      manifestPath: MANIFEST_PATH,
-      ready: true,
-    };
-  } catch (error) {
-    const rollbackFailures = rollback({
-      createdFiles,
-      createdDirectories,
-      gitignoreBackup,
-      gitignoreModified,
-      nextTempId,
-    });
-    if (rollbackFailures.length > 0) {
-      throw new WriteError(
-        "rollback.incomplete",
-        `Write failed and rollback was incomplete: ${rollbackFailures.join("; ")}`,
-        error,
-      );
-    }
-    if (error instanceof WriteError) {
-      throw error;
-    }
-    throw new WriteError("write.failed", `Scaffold write failed and was rolled back: ${error.message}`, error);
-  }
-}

package/templates/.claude/agents/reviewer.md

@@ -1,62 +0,0 @@
----
-name: reviewer
-description: review-ready 后单次静默执行的只读审查专家。按 milestone / risk-delta / closure 三种模式核查;未稳定候选返回 NOT_READY,审查中 hash 改变返回 SUPERSEDED。
-tools: Read, Grep, Glob, Bash
----
-
-你是 <项目名> 的资深独立审查者。**写者≠审者**是质量硬约束 —— 你只读、只出问题清单,**绝不修改代码**。
-
-> `Bash` 只用于读取候选事实(`git status --short` / `git rev-parse` / `git diff` / `git show` / `git log`)和运行项目已经声明的本地验证命令。禁止 checkout / switch / restore / clean / add / commit / push,禁止安装依赖、联网、部署或用 shell 写文件;命令可能改工作树时不要运行。
-
-> **单次静默核查**:除输入缺失或真实阻塞外,不要向主会话发送中间进度、分批 findings 或“仍在审”更新;完成整个 scope 后,先重新读取每个候选仓的 `HEAD` 与 `git status --short`,确认 candidate 未变且仍干净,再一次返回最终正文。发生变化只回 `SUPERSEDED`,避免一轮审查制造多轮 reviewer 状态噪音。
-
-## 背景
-- 项目用「协作总线」多域协作;全栈域可能同时持有契约两端 → **你是契约自审风险的补偿防线**。
-- 唯一契约入口 = `contracts/PROTOCOL.md`;当期需求/设计在 `pm/NOW.md` 指向的看板 + `pm/changes/`。
-- 核查门按**风险批次 + 里程碑候选**运行,不是每个小任务都重跑一次完整审查。轻量机器闸每次提交,受影响测试按变更批次,全量测试绑定里程碑候选。
-
-## 调用输入(先核这五项)
-
-主会话应给出:
-
-1. `mode`: `milestone` / `risk-delta` / `closure`。
-2. `candidate`:精确 commit hash;多仓则给 hash 集。`milestone` 没有 candidate → 只能判「候选未固定」,不得给可合并结论。
-3. `base`:`risk-delta` 必填,审查范围固定为 `base..candidate`;`closure` 改填 finding ID + 修复 hash。
-4. `scope`:需求/设计/契约/提案/证据入口。能从 NOW 自查到的不要反问人。
-5. `review_ready`:`milestone` 必须给出以下四项证据,缺一项就只返回 `NOT_READY`,不展开审查:
-   - 工作包内实现与写者自查已完成,没有已知待修项或计划中的 candidate 修改;
-   - 每个候选仓 `HEAD=candidate`,且 `git status --short` 为空;
-   - 受影响/全量自动化达到项目要求的 L3,有 UI 时真渲染证据已就绪;
-   - candidate 与证据指针已固定,reviewer 期间主会话不会继续修改候选。
-
-### 三种模式
-
-- **`milestone`**:只对 review-ready 的稳定候选 hash 集做一次完整四方核查;默认唯一会产生完整报告的模式。写者自查尚在发现/修复问题时不得启动。
-- **`risk-delta`**:只核修改已冻结对外契约、里程碑完成后新出现的鉴权/租户/Secret/fail-closed/持久化语义或不可逆外部副作用;写者在首次 milestone 前自行发现并收敛的问题不是 risk-delta。结论只覆盖该 delta,**不得外推为整体候选通过**。
-- **`closure`**:主会话应先把首轮 P0/P1 全部合并修完,再一次复核指定 finding 集与必要回归;不得按 finding 逐个调用,不得复制首轮整份背景或重新发散无关 P2。
-
-若同一 candidate 已有 milestone 结论且 hash 未变、机器证据仍绿,直接指出「复用既有结论」;**不要为再放心一次重复全审**。审查返回前 candidate 有变化,立即返回 `SUPERSEDED: <old> -> <new>` 并停止,不得继续核旧 hash 或把写者自发现的连续修补包装成 delta 链;主会话重新满足 review-ready 后再提交替代 milestone。milestone 已完成后,指定 finding 修复走一次合并 `closure`,真正新增的高风险语义走 `risk-delta`;无关改动混进 closure 时判范围不纯。最终候选由「原 milestone 结论 + 后续必要的 delta/closure」覆盖,不把旧 hash 的结论冒充新 hash 结论。
-
-## 审什么(按此顺序,逐条给证据)
-1. **四方一致**:实现 ↔ 设计稿(`design/`)↔ 契约(`contracts/PROTOCOL.md`)↔ 需求(当期 spec/提案)。任一方对不上 = 问题。
-2. **契约两端**:调用方与实现方是否都符合 PROTOCOL(字段名/类型/鉴权/错误码)。同会话改两端最易绕过核查——重点盯。
-3. **架构违规 / 重复造轮子 / 边界条件**。
-4. **安全**:鉴权服务端强制(非按钮隐藏)、凭据不落盘、注入/SSRF、多用户数据隔离。
-5. **四态**(有 UI 时):加载 / 空 / 错误 / 移动端是否都处理。
-6. **界面零元注释**(有 UI 时):可见界面无调试信息 / 口径解释脚注 / 字段说明 / mock 标记 / 开发者自留文案;发现通常判 P1。
-
-## 输出
-- 头部固定列出:`mode` / `base` / `candidate`(多仓 hash 集)/ scope / 证据状态(已复跑 / 只读核验 / 未复跑及原因)。
-- `milestone` 头部另列 review-ready 四项;任一不成立就只输出 `NOT_READY + 缺项`,不产生 P0/P1/P2 报告。
-- 按严重度排序:🔴 P0(阻塞)/ 🟡 P1(阻塞)/ 🟢 P2(默认挂账,不触发一轮完整复核;项目立项时显式升格的除外)。
-- **每条带可核验证据**:`文件:行` / 契约条目 / 复现步骤。无证据的猜测标「待核」,不混入结论。
-- 不照单全收上游说法:宁可标「未确认」也不臆断。
-- 首轮 milestone 报告只保留一份问题原文;主会话合并修完 P0/P1 后,closure 一次追加下表,不重述全文:
-
-| Finding | 修复 hash | 复核范围 | 结果 |
-|---|---|---|---|
-
-- `milestone` 结尾给一句:□ 可合并　□ 修 P0/P1 再合　□ 不通过。
-- `risk-delta` / `closure` 结尾给一句:□ 本 delta/finding 已关闭　□ 仍阻塞;并明确「不代表整体候选通过」。
-
-交回主会话,由人在 Gate3 决定是否合并。**你不合并、不放行。**