kld-sdd 2.7.8-2 → 2.7.8-3

package/templates/git-hooks/delivery-snapshot.cjs

@@ -0,0 +1,181 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const crypto = require('crypto');
+const { execFileSync } = require('child_process');
+
+const RULE_VERSION = 'sdd-delivery-v1';
+const digest = value => crypto.createHash('sha256').update(value).digest('hex');
+const hashJson = value => digest(JSON.stringify(value));
+const slash = value => value.replace(/\\/g, '/');
+
+// Git exports these during hooks. A different cwd alone does not switch repositories.
+function gitEnv() {
+  const env = { ...process.env };
+  for (const key of Object.keys(env)) {
+    if (/^GIT_(DIR|WORK_TREE|INDEX_FILE|COMMON_DIR|OBJECT_DIRECTORY|ALTERNATE_OBJECT_DIRECTORIES|PREFIX)$/.test(key)) delete env[key];
+  }
+  return env;
+}
+
+function git(root, args, options = {}) {
+  return execFileSync('git', args, {
+    cwd: root, env: { ...gitEnv(), ...(fs.realpathSync(root) === fs.realpathSync(process.cwd()) && process.env.GIT_INDEX_FILE ? { GIT_INDEX_FILE: path.resolve(process.env.GIT_INDEX_FILE) } : {}) }, encoding: 'utf8', timeout: 10000,
+    maxBuffer: 64 * 1024 * 1024, stdio: ['pipe', 'pipe', 'pipe'], ...options,
+  });
+}
+
+function repoIdentity(root) {
+  let remote = '';
+  try { remote = git(root, ['remote', 'get-url', 'origin']).trim(); } catch { /* local repo */ }
+  // Do not persist credentials from a remote URL.
+  remote = remote.replace(/(https?:\/\/)[^/@]+@/i, '$1').replace(/\.git$/, '').replace(/\/$/, '');
+  remote = remote.replace(/^git@([^:]+):/, '$1/').replace(/^https?:\/\//i, '');
+  const common = git(root, ['rev-parse', '--git-common-dir']).trim();
+  return remote || `local:${fs.realpathSync(path.resolve(root, common))}`;
+}
+
+function entriesAt(root, scope = 'worktree', ref = 'HEAD') {
+  if (scope === 'commit') {
+    const sha = git(root, ['rev-parse', '--verify', '--end-of-options', `${ref}^{commit}`]).trim();
+    return git(root, ['ls-tree', '-r', '-z', '--full-tree', sha]).split('\0').filter(Boolean).map(row => {
+      const tab = row.indexOf('\t'), [mode, type, oid] = row.slice(0, tab).split(' ');
+      return { path: row.slice(tab + 1), mode, oid, type };
+    });
+  }
+  const entries = git(root, ['ls-files', '--stage', '-z']).split('\0').filter(Boolean).map(row => {
+    const tab = row.indexOf('\t'), [mode, oid, stage] = row.slice(0, tab).split(' ');
+    if (stage !== '0') throw new Error('UNMERGED_INDEX: 请先解决 Git 冲突');
+    return { path: row.slice(tab + 1), mode, oid, type: mode === '160000' ? 'commit' : 'blob' };
+  });
+  if (scope === 'worktree') {
+    for (const file of git(root, ['ls-files', '--others', '--exclude-standard', '-z']).split('\0').filter(Boolean)) {
+      entries.push({ path: file, mode: '100644', type: 'blob' });
+    }
+  }
+  return entries;
+}
+
+function readBlobs(root, entries) {
+  const blobs = entries.filter(e => e.type === 'blob');
+  const result = new Map();
+  if (!blobs.length) return result;
+  const out = git(root, ['cat-file', '--batch'], { input: blobs.map(e => e.oid).join('\n') + '\n', encoding: null });
+  let offset = 0;
+  for (const entry of blobs) {
+    const end = out.indexOf(10, offset);
+    const header = out.subarray(offset, end).toString('ascii').split(' ');
+    if (end < 0 || header[1] !== 'blob' || !/^\d+$/.test(header[2])) throw new Error('GIT_BLOB_UNREADABLE');
+    const size = Number(header[2]);
+    offset = end + 1;
+    if (offset + size >= out.length) throw new Error('GIT_BLOB_TRUNCATED');
+    result.set(entry.path, out.subarray(offset, offset + size));
+    offset += size + 1;
+  }
+  return result;
+}
+
+function fileMeta(file, content, mode = '100644') {
+  // Git autocrlf changes text line endings between the worktree and index.
+  // Normalize valid UTF-8 text only; binary bytes and symlink targets stay exact.
+  const text = content.toString('utf8');
+  const isText = mode !== '120000' && !content.includes(0) && Buffer.from(text, 'utf8').equals(content);
+  const bytes = isText ? Buffer.from(text.replace(/\r\n/g, '\n'), 'utf8') : content;
+  return { path: file, mode, normalization: isText ? 'utf8-lf' : 'bytes', size: bytes.length, sha256: digest(bytes) };
+}
+
+function excluded(file, specRelative) {
+  if (specRelative && specRelative !== '.' && (file === specRelative || file.startsWith(specRelative + '/'))) return true;
+  return /(^|\/)(\.git|node_modules|target|dist|build|coverage|skywalk-sdd)(\/|$)/.test(file)
+    || /(^|\/)(consistency-report(?:-result)?\.(md|json)|consistency-reviews)(\/|$)/.test(file)
+    || /^(openspec|\.claude|\.cursor|\.codex|\.agents|\.qoder)\//.test(file);
+}
+
+function codeSnapshot(root, specRoot, scope = 'worktree', ref = 'HEAD') {
+  if (!['worktree', 'index', 'commit'].includes(scope)) throw new Error('SCOPE_INVALID');
+  const relative = slash(path.relative(root, specRoot));
+  const entries = entriesAt(root, scope, ref).filter(e => !excluded(e.path, relative.startsWith('..') ? '' : relative));
+  const blobs = scope === 'worktree' ? null : readBlobs(root, entries);
+  let trustFileMode = true;
+  try { trustFileMode = git(root, ['config', '--bool', 'core.filemode']).trim() !== 'false'; } catch { /* Git default */ }
+  const files = [];
+  for (const entry of entries) {
+    if (entry.type === 'commit') {
+      // Submodules require a separate delivery check in that repository.
+      files.push({ path: entry.path, mode: entry.mode, gitlink: entry.oid });
+      continue;
+    }
+    let content, mode = entry.mode;
+    if (scope === 'worktree') {
+      const fp = path.join(root, entry.path);
+      if (!fs.existsSync(fp) && !fs.lstatSync(fp, { throwIfNoEntry: false })) continue;
+      const stat = fs.lstatSync(fp);
+      if (stat.isSymbolicLink()) { content = Buffer.from(fs.readlinkSync(fp)); mode = '120000'; }
+      else { content = fs.readFileSync(fp); mode = trustFileMode ? (stat.mode & 0o111 ? '100755' : '100644') : entry.mode; }
+    } else content = blobs.get(entry.path);
+    if (!content) throw new Error(`UNREADABLE: ${entry.path}`);
+    files.push(fileMeta(entry.path, content, mode));
+  }
+  return files.sort((a, b) => a.path.localeCompare(b.path, 'en'));
+}
+
+function isSpecInput(file, change) {
+  if (file.startsWith(`openspec/changes/${change}/logs/`) || file.startsWith(`openspec/changes/${change}/reports/`)) return false;
+  if (/(^|\/)(consistency-report(?:-result)?\.(json|md)|consistency-reviews)(\/|$)/.test(file)) return false;
+  return file === 'modules.yaml' || file === 'sdd.config.yaml' || file === 'openspec/config.yaml'
+    || file.startsWith('openspec/specs/') || file.startsWith(`openspec/changes/${change}/`);
+}
+
+function specSnapshot(specRoot, change, options = {}) {
+  if (!/^[a-z0-9][a-z0-9-]+$/.test(change)) throw new Error('CHANGE_REQUIRED: 必须明确指定 change');
+  const files = [];
+  if (options.scope === 'commit' || options.scope === 'index') {
+    const root = options.root || specRoot;
+    const prefix = slash(path.relative(root, specRoot));
+    const start = prefix ? prefix + '/' : '';
+    const entries = entriesAt(root, options.scope, options.ref).filter(e => e.path.startsWith(start) && isSpecInput(e.path.slice(start.length), change));
+    const blobs = readBlobs(root, entries);
+    for (const entry of entries) {
+      if (entry.mode === '120000' || entry.type !== 'blob') throw new Error('SPEC_INPUT_SYMLINK_OR_SUBMODULE');
+      files.push(fileMeta(entry.path.slice(start.length), blobs.get(entry.path), entry.mode));
+    }
+  } else {
+    const walk = (relative) => {
+      const fp = path.join(specRoot, relative);
+      if (!fs.existsSync(fp)) return;
+      const stat = fs.lstatSync(fp);
+      if (stat.isSymbolicLink()) throw new Error(`SPEC_INPUT_SYMLINK: ${relative}`);
+      if (stat.isDirectory()) {
+        for (const name of fs.readdirSync(fp)) walk(relative ? `${relative}/${name}` : name);
+      } else if (isSpecInput(relative, change)) files.push(fileMeta(relative, fs.readFileSync(fp)));
+    };
+    for (const relative of ['modules.yaml', 'sdd.config.yaml', 'openspec/config.yaml', 'openspec/specs', `openspec/changes/${change}`]) walk(relative);
+  }
+  if (!files.some(f => f.path === `openspec/changes/${change}/proposal.md`)) throw new Error(`CHANGE_MISSING: ${change}`);
+  files.sort((a, b) => a.path.localeCompare(b.path, 'en'));
+  return { files, sha256: hashJson(files) };
+}
+
+function changedFiles(root, scope, base, ref = 'HEAD') {
+  const args = ['diff', '--name-only', '--no-renames', '-z'];
+  if (scope === 'index') args.push('--cached');
+  if (base) args.push(base);
+  if (scope === 'commit') {
+    if (!base) throw new Error('BASE_REQUIRED: 提交校验必须明确提供比较基线');
+    args.push(ref);
+  }
+  args.push('--');
+  const result = git(root, args).split('\0').filter(Boolean);
+  if (scope === 'worktree') result.push(...git(root, ['ls-files', '--others', '--exclude-standard', '-z']).split('\0').filter(Boolean));
+  return [...new Set(result)].sort();
+}
+
+function atomicJson(file, value) {
+  fs.mkdirSync(path.dirname(file), { recursive: true });
+  const temp = `${file}.${process.pid}.${crypto.randomBytes(6).toString('hex')}.tmp`;
+  fs.writeFileSync(temp, JSON.stringify(value, null, 2) + '\n');
+  fs.renameSync(temp, file);
+}
+
+module.exports = { RULE_VERSION, digest, hashJson, git, gitEnv, repoIdentity, entriesAt, readBlobs, fileMeta, codeSnapshot, specSnapshot, changedFiles, atomicJson, excluded };

package/templates/git-hooks/hooks.config

@@ -1,3 +1,5 @@
+# 默认仅安装 commit-msg；pre-commit/pre-push 段仅供已有显式集成使用。
+# Apply 自动运行 delivery-check；安装不会替团队开启 CI 门禁。
 # KLD SDD Hook 插件配置文件
 # 每行一个脚本名，空行和 # 开头的行会被忽略
 # 注释某行 = 禁用该插件，取消注释 = 启用该插件
@@ -9,13 +11,13 @@ commit-msg-sdd-trailer.cjs
 [pre-commit]
 # 检查 tasks.md 中是否有未完成的归档任务
 pre-commit-sdd-check.cjs
-# 检查 Spec 一致性校验报告（置信度、过期、人工确认等）
+# 检查 Spec 一致性校验报告（输入指纹、覆盖与实际检查结果）
 pre-commit-consistency-check.cjs
 
 [pre-push]
 # 运行 doctor 完整诊断（配置、Trailer 协议、活动变更等）
 pre-push-sdd-check.cjs
-# 检查待推送范围的一致性报告（存在性、过期；置信度由 pre-commit 负责）
+# 检查待推送范围的一致性报告（实际 push refs；需显式 Change 和真实测试回执）
 pre-push-consistency-check.cjs
 
 [consistency]
@@ -24,15 +26,15 @@ pre-push-consistency-check.cjs
 # Go / Kotlin 等项目按需修改：
 # 注意：新增语言的语言特定构建文件（如 Rust 的 build.rs）不在内置排除规则内，需自行确认
 # 本配置同时被 git hook（isBusinessCode）与 opsx-consistency-check skill 读取，单一来源
-# ⚠️ 清空本行 = 不拦截任何业务代码文件（一致性门禁对提交/推送失效，仅剩报告存在性/过期检查）
+# 清空本行时严格交付检查会失败，不能将范围未知视为通过。
 business_code_exts = .java,.ts,.tsx,.js,.jsx,.vue,.py
 
 # 一致性校验模式（项目级默认值，环境变量优先覆盖；三个互斥，只能启用一个）
 # 环境变量：SDD_SKIP_CONSISTENCY_CHECK=1 / SDD_STRICT_CONSISTENCY=1 / SDD_WARN_ONLY=1
 # - skip = 1：跳过一致性校验（紧急绕过，如 hotfix 仓不需要 spec 校验）
-# - strict = 1：严格模式，medium 置信度也阻止提交（仅 pre-commit 生效，pre-push 忽略）
+# - strict = 1：保留旧项目显式门禁选择；交付检查始终要求完整事实证据
 # - warn_only = 1：仅告警不拦截（CI 调试期，问题全列但不阻断提交/推送）
-# 三项均不设或均设为 0 = 默认模式（low 阻止，medium 放行，high 放行）
+# 三项均不设或均设为 0 = 检查回执、输入指纹与覆盖；不按置信度放行
 skip = 0
 strict = 0
-warn_only = 0
+warn_only = 0

package/templates/git-hooks/pre-commit-consistency-check.cjs

@@ -1,45 +1,27 @@
 #!/usr/bin/env node
-/**
- * pre-commit-consistency-check.cjs
- *
- * Pre-commit 门禁：检查本次提交 diff 涉及的 Spec 一致性校验报告。
- * - diff 驱动：仅检查 diff 文件与报告 coveredFiles 有交集的 change，无关 change 跳过
- * - 报告存在性：活跃 change 无报告 → 阻止提交
- * - 报告过期：代码在报告生成后被修改 → 阻止提交
- * - 置信度门禁：confidence=low → 阻止提交；strict 模式下 medium 也阻止
- *
- * 通过环境变量控制：
- * - SDD_SKIP_CONSISTENCY_CHECK=1 → 跳过校验
- * - SDD_STRICT_CONSISTENCY=1 → 严格模式（medium 也阻止）
- * - SDD_WARN_ONLY=1 → 仅告警不拦截
- * - 注意：三个环境变量互斥，只能启用一个
- *
- * 共享逻辑见同目录 consistency-check-core.cjs。
+/** Optional strict index verification. Not installed on daily commits by default.
+ * Checks complete coverage, input fingerprints and actual review dimensions.
+ * SDD_SKIP_CONSISTENCY_CHECK / SDD_WARN_ONLY remain explicit legacy overrides.
  */
 'use strict';
 
 const core = require('./consistency-check-core.cjs');
-const { gitDiffNameStatus } = core;
 
-/**
- * 单仓 diff 采集：工作区相对 HEAD 的变更（含 staged 与未 staged）。
- * files=修改/新增（排除删除）；deleted=删除文件。
- * 空仓（无任何 commit）时 HEAD 不存在：降级用 staged 文件列表。
- * @returns {{files: string[], deleted: string[], ok: boolean}} ok=false 表示无法确定变更范围
- */
+/** Inspect the actual staged content, including an unborn repository and deletions. */
 function gitDiffHead(repoRoot) {
-  const bases = [['diff', 'HEAD'], ['diff', '--cached']];
-  for (const base of bases) {
-    const r = gitDiffNameStatus(repoRoot, base);
-    if (r.ok) return r;
-  }
-  return { files: [], deleted: [], ok: false };
+  try {
+    const snap = require('./delivery-snapshot.cjs');
+    const changed = snap.changedFiles(repoRoot, 'index');
+    const indexed = new Set(snap.entriesAt(repoRoot, 'index').map(e => e.path));
+    return { files: changed.filter(f => indexed.has(f)), deleted: changed.filter(f => !indexed.has(f)), ok: true };
+  } catch { return { files: [], deleted: [], ok: false }; }
 }
 
 core.runConsistencyCheck({
   label: '[SDD commit-consistency-check]',
   actionNoun: '提交',
   diffFn: gitDiffHead,
-  checkConfidence: true, // 置信度校验由 pre-commit 完成
-  includeUntracked: true, // 新文件将随本次提交入库，需检查
+  checkConfidence: true, // Legacy option; factual review dimensions now decide readiness.
+  includeUntracked: false, // Only the index is part of this commit.
+  staleFromIndex: true,
 });

package/templates/git-hooks/pre-push-consistency-check.cjs

@@ -1,88 +1,41 @@
 #!/usr/bin/env node
-/**
- * pre-push-consistency-check.cjs
- *
- * Pre-push 轻量门禁：仅检查待推送范围涉及报告的存在性、是否过期。
- * - diff 驱动：仅检查待推送文件与报告 coveredFiles 有交集的 change，无关 change 跳过
- * - 完整的置信度校验由 pre-commit 完成，push 阶段不再重复。
- * - 过期判断读取 HEAD 已提交内容（而非工作区），避免工作区未提交修改造成误判。
- *
- * 待推送范围采集（逐级降级）：
- *   1. git diff @{push}..HEAD（本地领先远程的提交）
- *   2. git diff origin/HEAD..HEAD
- *   3. 远程引用不存在（新分支/新仓库首次推送）：git diff <空树>..HEAD，
- *      语义 = 首推时 HEAD 全部文件都是新增。空树 SHA 是 git 内置常量，
- *      不依赖任何远程引用，避免「首推因无远程引用被拦 → 引用永远建立不起来」的死锁
- *   4. 连空树 diff 都失败（如空仓无 HEAD）：返回 ok=false，由 core 拦截推送而非静默放行
- *
- * 通过环境变量控制：
- * - SDD_SKIP_CONSISTENCY_CHECK=1 → 跳过校验
- * - SDD_WARN_ONLY=1 → 仅告警不拦截
- * - 注意：两个环境变量互斥，只能启用一个
- *
- * 共享逻辑见同目录 consistency-check-core.cjs。
- */
 'use strict';
-
-const core = require('./consistency-check-core.cjs');
-const { gitDiffNameStatus } = core;
-const { execFileSync } = require('child_process');
-
-// git 内置空树对象 SHA（SHA-1 仓库恒定不变）
-const EMPTY_TREE_SHA = '4b825dc642cb6eb9a060e54bf8d69288fbee4904';
-
-/**
- * 单仓待推送范围采集：本地领先远程的提交所涉及的文件。
- * files=修改/新增（排除删除）；deleted=删除文件。
- * @returns {{files: string[], deleted: string[], ok: boolean}}
- */
-function gitPushRangeDiff(repoRoot) {
-  const ranges = ['@{push}..HEAD', 'origin/HEAD..HEAD'];
-  for (const range of ranges) {
-    const r = gitDiffNameStatus(repoRoot, ['diff', range]);
-    if (r.ok) return r;
-  }
-  // 首推降级：远程引用不存在（@{push}/origin/HEAD 均无法解析）时，
-  // 用 git 内置空树 SHA 做 diff —— 语义为「首推 = HEAD 全部文件都是新增」。
-  // 空树对象不依赖任何远程引用，打破「首推被拦 → 远程引用永远建立不起来」的死锁。
-  const emptyTree = gitEmptyTreeSha(repoRoot);
-  if (emptyTree) {
-    const r = gitDiffNameStatus(repoRoot, ['diff', `${emptyTree}..HEAD`]);
-    if (r.ok) return r;
-  }
-  // 连空树 diff 都失败（如空仓无 HEAD）：返回失败，由 core 拦截而非静默放行
-  return { files: [], deleted: [], ok: false };
+// Optional legacy integration. New installs do not validate on every push.
+const fs = require('fs');
+const path = require('path');
+const snap = require('./delivery-snapshot.cjs');
+const delivery = require('./delivery-check.cjs');
+const mode = require('./consistency-check-core.cjs').loadConsistencyMode();
+const skip = process.env.SDD_SKIP_CONSISTENCY_CHECK === undefined ? mode.skip : process.env.SDD_SKIP_CONSISTENCY_CHECK === '1';
+const warnOnly = process.env.SDD_WARN_ONLY === undefined ? mode.warnOnly : process.env.SDD_WARN_ONLY === '1';
+const strict = process.env.SDD_STRICT_CONSISTENCY === undefined ? mode.strict : process.env.SDD_STRICT_CONSISTENCY === '1';
+if ([skip, warnOnly, strict].filter(Boolean).length > 1) {
+  console.error('[SDD] skip / warn_only / strict 互斥'); process.exit(1);
 }
-
-/**
- * 读取 git 内置空树 SHA（4b825dc642cb6eb9a060e54bf8d69288fbee4904）。
- * 优先用 git mktree 动态计算（兼容 SHA-256 仓库），失败时回退内置常量。
- * @param {string} repoRoot
- * @returns {string|null}
- */
-function gitEmptyTreeSha(repoRoot) {
-  try {
-    const sha = execFileSync('git', ['mktree'], {
-      cwd: repoRoot, encoding: 'utf8', input: '', stdio: ['pipe', 'pipe', 'ignore'],
-    }).trim();
-    if (/^[0-9a-f]{40,64}$/.test(sha)) return sha;
-  } catch {
-    // 降级到内置常量
+if (skip) { console.log('[SDD] 按显式配置跳过推送检查（未验证）'); process.exit(0); }
+try {
+  const project = path.resolve(process.argv.find(a => a.startsWith('--project='))?.slice(10) || process.cwd());
+  const specRoot = path.resolve(__dirname, '..', '..');
+  const changes = String(process.env.KLD_SDD_CHANGE || '').split(/[,\s]+/).filter(Boolean);
+  const refs = (process.env.SDD_PRE_PUSH_REFS || (process.stdin.isTTY ? '' : fs.readFileSync(0, 'utf8'))).replace(/\\n/g, '\n').trim();
+  if (!refs) throw new Error('PUSH_REFS_REQUIRED: 需要真实 pre-push refs；手动验证请运行 delivery-check verify');
+  for (const line of refs.split(/\r?\n/)) {
+    const fields = line.trim().split(/\s+/);
+    if (fields.length !== 4 || fields.some((f, i) => i % 2 === 1 && !/^[a-f0-9]{40}$|^[a-f0-9]{64}$/.test(f))) throw new Error('PUSH_REFS_INVALID');
+    const [, localSha, , remoteSha] = fields;
+    if (/^0+$/.test(localSha)) continue;
+    if (!changes.length) throw new Error('CHANGE_REQUIRED: 严格推送检查需要 KLD_SDD_CHANGE 明确关联');
+    const base = /^0+$/.test(remoteSha) ? snap.git(project, ['mktree'], { input: '' }).trim() : remoteSha;
+    const revisions = snap.git(project, ['show', '-s', '--format=%(trailers:key=Spec-Revision,valueonly)', localSha]).trim().split(/\s+/).filter(Boolean);
+    for (const change of changes) {
+      const result = delivery.verify({ project, 'spec-root': specRoot, change, scope: 'commit', ref: localSha, base,
+        'spec-ref': revisions.length === 1 ? revisions[0] : undefined });
+      if (!result.ok) throw new Error(result.errors.join('; '));
+    }
   }
-  return /^[0-9a-f]{40}$/.test(EMPTY_TREE_SHA) ? EMPTY_TREE_SHA : null;
-}
-
-// strict 模式仅 pre-commit 支持：显式提示而非静默忽略
-const _mode = core.loadConsistencyMode();
-if (process.env.SDD_STRICT_CONSISTENCY === '1' || _mode.strict) {
-  console.log('[SDD push-consistency-check] ℹ️  SDD_STRICT_CONSISTENCY 仅在 pre-commit 阶段生效，push 阶段忽略');
+  console.log('[SDD] 指定推送提交的交付证据验证通过');
+} catch (error) {
+  console.error(`[SDD] ${error.message}`);
+  if (warnOnly) console.error('[SDD] 仅告警模式，推送继续（交付仍未验证）');
+  process.exitCode = warnOnly ? 0 : 1;
 }
-
-core.runConsistencyCheck({
-  label: '[SDD push-consistency-check]',
-  actionNoun: '推送',
-  diffFn: gitPushRangeDiff,
-  checkConfidence: false, // 置信度校验由 pre-commit 完成，push 阶段不重复
-  includeUntracked: false, // untracked 文件不在任何 commit 中，不会被推送
-  staleFromHead: true, // 过期判断读 HEAD 已提交内容，避免工作区未提交修改误判
-});

package/templates/openspec/proposal.md

@@ -7,7 +7,7 @@ module: "<module>" # modules.yaml 中的模块代号；跨模块用 cross
 # affected-modules: # 仅 module=cross 时必填，至少两个已注册模块
 #   - fi
 #   - mm
-entity-id: "<8位十六进制ID>" # Change 的全局逻辑实体 ID，added 时生成
+entity-id: "<完整UUID>" # Change 的全局逻辑实体 ID，added 时生成
 version-id: "<UUID>" # 本次 Change 版本 UUID
 delta-state: "added"
 predecessor-version: "" # added 留空；modified/removed 指向直接前序版本

package/templates/skills/kld-sdd/opsx-apply/SKILL.md

@@ -293,33 +293,35 @@ g. **继续下一个层级** — 重新检查 DAG，找出依赖已满足的下
 
 ### 6. 完成或暂停时显示状态
 
-展示 DAG 执行摘要，引导下一步：
-> "📊 **实施进度摘要**：
-> - 已完成：[N/M] 任务
-> - 当前层级：Layer [X]
-> - 下一步建议：[继续实施 / 运行测试 / 归档]"
-
-**【已授权连续处理完成】**
-若本次为用户已授权的连续处理，完成时展示一次整体交付结果：
-> "✅ **本轮连续处理完成**
-> - propose → spec → design → task → check → apply 已全部执行完毕
-> - 各阶段文档已生成，质量门禁已执行
-> - 建议下一步：运行测试 / 归档变更"
-
-> **💡 代码评审提示**：
-> 建议执行 `/kld-review --local` 对本次变更的代码进行评审。
-> 该技能可在公司内部 SkillHub 下载安装。
->
-> **🧹 Worktree 收尾**：若本次使用了 worktree，见 **§6.1**；若判定未建 worktree，跳过 §6.1。
-> **其他 capability**：若并行 apply 中仍有未 finish 的 worktree，提示按 proposal 依赖顺序继续 `finish`。
+先执行下面的收尾验证，再展示实施摘要。验证未完成时显示「代码已保存，交付待验证」并列出缺口，不展示「全部完成」或把测试留给用户手动执行。
+
+### 6.0 实施收尾：自动检查、测试与就绪判定
+
+此节由 Agent 在当前授权范围内连续执行，无需用户串联多个 Skills。`opsx-check` 的文档结果不替代代码检查。
+
+1. 整理任务状态和最终 Spec 后，调用 `opsx-consistency-check`，明确本次 Change、代码仓以及实施前基线。回执有效则复用；失效时定向重查。多仓只检查本次涉及的仓，每仓独立保留证据。
+2. 使用下列入口执行最终回归测试；它内部调用原 `test-run`，保留严格测试事件、原始日志和任务关联，不重复手写相同测试事件。已有任务级 RED/GREEN 证据继续保留。命令必须是真实测试或项目认可的验证命令，不能用 `echo`、空测试冒充验证。
+
+   ```bash
+   node "<spec-root>/skywalk-sdd/git-hooks/delivery-check.cjs" test --project="<代码仓>" --change=<change> --session-id=<会话ID> --task-ids=<任务ID列表> --command-file="<测试命令JSON数组文件>"
+   ```
+
+   命令文件放在 prepare 输出的状态目录，内容如 `["node","--test","test/order.test.cjs"]`。脚本取证前后核对输入；测试修改代码或 Spec 时，本次回执失效。详细 RED/GREEN 与任务完成证据仍见 `./reference.md`「§6.0」和 `./checklist.md`。
+3. 执行就绪判断，失败就修复并补足对应证据；正常 Git 保存和本地编辑仍可继续。
+
+   ```bash
+   node "<spec-root>/skywalk-sdd/git-hooks/delivery-check.cjs" verify --project="<代码仓>" --change=<change>
+   ```
+
+`status=ready` 只表示该快照的本地检查和测试证据完整。不得把它表述为已入库、已发布或已合并。只有本次无业务代码变化、四个检查维度均有依据判为不适用，且检查回执显式写入 `tests: {"status":"na","reason":"具体理由"}` 时，工具才允许省略测试并显示 `testStatus=not_applicable`。其余缺少可执行验证命令的项目标记待验证，不凭模型文字造测试。`test-strategy=none` 免除任务级 TDD，不自动证明交付验证通过。
 
-### 6.0 【条件必做】单元测试真实执行（`test-strategy` 非 `none`）
+收尾合并或提交后，若需验证最终提交，运行 `verify --scope=commit --ref=<目标SHA> --base=<实施前SHA>`；多仓再提供 `--spec-ref=<实际验证的完整Spec提交SHA>`。工具读取指定 Git 对象，不读取别的 HEAD 或工作区替代。冲突修复改变内容时重新检查和测试。
 
-当 `proposal.md` 的 `test-strategy` 为 **`tdd`** 或 **`impl-first`** 时，在结束 apply 或执行 §6.1 收尾之前，必须真实运行单元测试并留 telemetry 证据。**详细执行要求与证据形式见 `./reference.md`「§6.0」+ `./checklist.md`「§6.0 单元测试真实执行自检」**。${HOOK_GATE_DESCRIPTION}
+所有涉及仓验证完成后，才输出整体结果：完成范围、真实验证结果、知识发布状态和剩余问题。现有 start/end、final_output_snapshot、使用上报照常执行。没有自动启用 CI；团队可将同一严格命令接入实际合并流程，并提供对应回执和测试原始日志。
 
 ### 6.1 【条件必做】Worktree 收尾（仅当 §1.5 已创建 worktree）
 
-> **⛔ 本次 Apply 若创建了 worktree**：DAG 全部完成且 §6.0 测试门禁（若适用）通过后，必须在**主仓库根目录**执行收尾脚本（禁止在 `.worktrees/...` 内执行）。
+> **⛔ 本次 Apply 若创建了 worktree**：DAG 全部完成且 §6.0 交付验证通过后，必须在**主仓库根目录**执行收尾脚本（禁止在 `.worktrees/...` 内执行）。
 > 若 §1.5 判定未建 worktree（串行、强依赖、沙箱回退），跳过本节。
 
 **前置条件、执行命令、脚本行为、常用 flags、回退方式见 `./reference.md`「§6.1 Worktree 收尾」+ `./checklist.md`「§6.1 Worktree 收尾前置条件自检」**。