kld-sdd 2.6.5 → 2.6.7

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "kld-sdd",
-  "version": "2.6.5",
+  "version": "2.6.7",
   "description": "KLD SDD OpenSpec 项目初始化工具 - 一键部署 SDD skills",
   "main": "index.js",
   "bin": {
@@ -8,7 +8,7 @@
     "kld-sdd-init": "bin/kld-sdd-init.js"
   },
   "scripts": {
-    "test": "node test/ontology-release-blockers.cjs && node test/ontology-semantic-core.cjs && node test/ontology-identity-versioning.cjs && node test/ontology-identity-continuity.cjs && node test/ontology-state-transaction.cjs && node test/ontology-process-concurrency.cjs && node test/ontology-observer-convergence.cjs && node test/ontology-working-runtime.cjs && node test/ontology-stage-materialization.cjs && node test/ontology-template-contract.cjs && node test/ontology-cli-archive.cjs && node test/archive-package-producer.cjs && node test/validate-skills-bundle.cjs && node test/tool-profiles.cjs && node test/settings-merge.cjs && node test/command-bridge.cjs && node test/codebuddy-hooks.cjs && node test/skill-content-contract.cjs && node test/init-agent-profiles.cjs"
+    "test": "node test/external-key.cjs && node test/ontology-release-blockers.cjs && node test/ontology-semantic-core.cjs && node test/ontology-identity-versioning.cjs && node test/ontology-identity-continuity.cjs && node test/ontology-state-transaction.cjs && node test/ontology-process-concurrency.cjs && node test/ontology-observer-convergence.cjs && node test/ontology-working-runtime.cjs && node test/ontology-stage-materialization.cjs && node test/ontology-template-contract.cjs && node test/ontology-cli-archive.cjs && node test/archive-package-producer.cjs && node test/validate-skills-bundle.cjs && node test/tool-profiles.cjs && node test/settings-merge.cjs && node test/command-bridge.cjs && node test/codebuddy-hooks.cjs && node test/skill-content-contract.cjs && node test/init-agent-profiles.cjs"
   },
   "keywords": [
     "kld",

package/skywalk-sdd/context-client.cjs

@@ -132,7 +132,18 @@ function buildPayload(args, mode) {
   if (args['entity-type']) payload.entityType = args['entity-type'];
   if (args['external-system']) payload.externalSystem = args['external-system'];
   if (args['external-object-type']) payload.externalObjectType = args['external-object-type'];
-  if (args['external-id']) payload.externalId = args['external-id'];
+  if (args['external-id']) {
+    const externalKey = require('./ontology/external-key.cjs');
+    const objectType = args['external-object-type'] || 'requirement';
+    const check = externalKey.validate(args['external-id'], objectType);
+    if (!check.ok) {
+      throw new Error(`${check.code}: ${check.message}`);
+    }
+    payload.externalId = externalKey.normalize(args['external-id'], objectType);
+    if (payload.externalObjectType) {
+      payload.externalObjectType = String(payload.externalObjectType).trim().toLowerCase();
+    }
+  }
   if (args['canonical-key']) payload.canonicalKey = args['canonical-key'];
   return payload;
 }

package/skywalk-sdd/ontology/archive-package.cjs

@@ -101,26 +101,107 @@ function requiredText(value, field, owner) {
 }
 
 function normalizeExternalRefs(refs) {
+  const { normalize } = require('./external-key.cjs');
   if (!Array.isArray(refs)) return [];
   const seen = new Set();
   const result = [];
   for (const ref of refs) {
     const system = String(ref.system || ref.system_name || '').trim();
     const objectType = String(ref.object_type || ref.objectType || '').trim().toLowerCase();
-    const externalId = String(ref.external_id || ref.externalId || '').trim();
-    if (!system || !objectType || !externalId) continue;
+    const rawExternalId = String(ref.external_id || ref.externalId || '').trim();
+    if (!system || !objectType || !rawExternalId) continue;
+    const externalId = normalize(rawExternalId, objectType) || rawExternalId;
     const key = `${system}\0${objectType}\0${externalId}`;
     if (seen.has(key)) continue;
     seen.add(key);
-    result.push({
+    const entry = {
       system,
       object_type: objectType,
       external_id: externalId,
-    });
+    };
+    const rawFeatureId = ref.feature_id || ref.featureId;
+    if (rawFeatureId && objectType === 'requirement') {
+      entry.feature_id = normalize(String(rawFeatureId), 'feature') || String(rawFeatureId).trim();
+    }
+    result.push(entry);
   }
   return result;
 }
 
+function expandRequirementRefsWithFeatures(requirementRefs) {
+  const expanded = [];
+  for (const ref of requirementRefs) {
+    expanded.push(ref);
+    if (ref.object_type === 'requirement' && ref.feature_id) {
+      expanded.push({
+        system: ref.system,
+        object_type: 'feature',
+        external_id: ref.feature_id,
+      });
+    }
+  }
+  return normalizeExternalRefs(expanded);
+}
+
+function assertExternalKeyFinalGate(entities) {
+  const {
+    validate,
+    normalize,
+    parseScenario,
+    CODES,
+  } = require('./external-key.cjs');
+  const packageRequirementIds = new Set();
+  for (const entity of entities) {
+    for (const ref of entity.external_refs || []) {
+      if (ref.object_type === 'requirement') {
+        packageRequirementIds.add(normalize(ref.external_id, 'requirement'));
+      }
+    }
+  }
+  for (const entity of entities) {
+    const declaredFeatures = new Set();
+    const featureBindings = new Set();
+    for (const ref of entity.external_refs || []) {
+      const format = validate(ref.external_id, ref.object_type);
+      if (!format.ok) {
+        throw new Error(`${CODES.FORMAT_INVALID}: ${format.message} @ ${entity.anchor_id}`);
+      }
+      if (ref.feature_id) {
+        const featureFormat = validate(ref.feature_id, 'feature');
+        if (!featureFormat.ok) {
+          throw new Error(`${CODES.FORMAT_INVALID}: requirement.feature_id 不合规: ${featureFormat.message} @ ${entity.anchor_id}`);
+        }
+        declaredFeatures.add(normalize(ref.feature_id, 'feature'));
+      }
+      if (ref.object_type === 'feature') {
+        featureBindings.add(normalize(ref.external_id, 'feature'));
+      }
+      if (ref.object_type === 'scenario') {
+        const parts = parseScenario(ref.external_id);
+        if (!parts || !packageRequirementIds.has(parts.requirementId)) {
+          throw new Error(
+            `${CODES.SCOPE_MISMATCH}: 场景键 REQ 前缀不在同包 requirement 绑定集合中: ${ref.external_id} @ ${entity.anchor_id}`,
+          );
+        }
+      }
+    }
+    for (const featureId of featureBindings) {
+      if (!declaredFeatures.has(featureId)) {
+        throw new Error(
+          `${CODES.FEATURE_UNDECLARED}: feature 绑定无法与同实体 requirement.feature_id 配对: ${featureId} @ ${entity.anchor_id}`,
+        );
+      }
+    }
+    for (const featureId of declaredFeatures) {
+      if (!featureBindings.has(featureId)) {
+        throw new Error(
+          `${CODES.FEATURE_UNDECLARED}: requirement 申报了 feature_id 但缺少对应 feature 绑定: ${featureId} @ ${entity.anchor_id}`,
+        );
+      }
+    }
+  }
+}
+
 function canonicalEntity(archiveDir, entity, inheritedRequirementRefs = []) {
   const anchorId = requiredText(entity.anchor_id || entity.id, 'anchor_id', '本体实体').toUpperCase();
   const versionId = requiredText(
@@ -130,8 +211,15 @@ function canonicalEntity(archiveDir, entity, inheritedRequirementRefs = []) {
   ).toLowerCase();
   const entityType = requiredText(entity.type, 'type', anchorId);
   let externalRefs = normalizeExternalRefs(entity.external_refs || entity.externalRefs || []);
-  if (entityType === 'Capability' && inheritedRequirementRefs.length > 0) {
-    externalRefs = normalizeExternalRefs([...externalRefs, ...inheritedRequirementRefs]);
+  if (entityType === 'Capability') {
+    const requirementSources = [
+      ...externalRefs.filter((ref) => ref.object_type === 'requirement'),
+      ...inheritedRequirementRefs,
+    ];
+    externalRefs = normalizeExternalRefs([
+      ...externalRefs,
+      ...expandRequirementRefsWithFeatures(requirementSources),
+    ]);
   }
   return {
     anchor_id: anchorId,
@@ -237,6 +325,7 @@ function buildCanonicalFacts(archiveDir, snapshot, projectId, archiveId) {
   if (entities.length === 0) {
     throw new Error('archive-ontology.json 没有可导出的实体');
   }
+  assertExternalKeyFinalGate(entities);
   const entityByAnchor = new Map(entities.map((entity) => [entity.anchor_id, entity]));
   const warningCounts = new Map();
   const seenRelations = new Set();

package/skywalk-sdd/ontology/artifact-parser.cjs

@@ -201,15 +201,28 @@ function identityFromValues(values = {}) {
 
 function flushRequirementRef(requirementRefs, currentRef) {
   if (!currentRef) return null;
+  const { normalize, validate } = require('./external-key.cjs');
   const system = currentRef.system;
   const objectType = currentRef['object-type'] || currentRef.object_type;
   const externalId = currentRef['external-id'] || currentRef.external_id;
+  const featureId = currentRef['feature-id'] || currentRef.feature_id;
   if (system && objectType && externalId) {
-    requirementRefs.push({
+    const type = String(objectType).toLowerCase();
+    const entry = {
       system,
-      object_type: String(objectType).toLowerCase(),
-      external_id: externalId,
-    });
+      object_type: type,
+      external_id: normalize(externalId, type) || String(externalId).trim(),
+    };
+    if (featureId) {
+      const featureCheck = validate(featureId, 'feature');
+      if (!featureCheck.ok) {
+        entry.feature_id_invalid = featureCheck.message;
+        entry.feature_id_raw = featureId;
+      } else {
+        entry.feature_id = normalize(featureId, 'feature');
+      }
+    }
+    requirementRefs.push(entry);
   }
   return null;
 }
@@ -218,8 +231,10 @@ function parseStructuredFrontmatter(lines) {
   const flat = {};
   const requirementRefs = [];
   const continuity = {};
+  const numberingWaiver = {};
+  let numberingGate = false;
   if (!lines.length || lines[0].trim() !== '---') {
-    return { flat, requirementRefs, continuity };
+    return { flat, requirementRefs, continuity, numberingWaiver, numberingGate };
   }
   let section = null;
   let currentRef = null;
@@ -238,6 +253,13 @@ function parseStructuredFrontmatter(lines) {
       flat[section] = value;
       currentCap = null;
       if (section === 'continuity' && value) continuity.kind = value;
+      if (section === 'numbering-waiver') {
+        numberingGate = true;
+        if (value) numberingWaiver.reason = value;
+      }
+      if (section === 'requirement-refs') {
+        numberingGate = true;
+      }
       continue;
     }
 
@@ -253,6 +275,12 @@ function parseStructuredFrontmatter(lines) {
       continue;
     }
 
+    if (section === 'numbering-waiver' && nested) {
+      const key = nested[1].toLowerCase().replace(/-/g, '_');
+      numberingWaiver[key] = unwrapScalar(stripInlineYamlComment(nested[2]));
+      continue;
+    }
+
     if (section === 'continuity' && nested) {
       const key = nested[1].toLowerCase().replace(/-/g, '_');
       const value = unwrapScalar(stripInlineYamlComment(nested[2]));
@@ -280,7 +308,7 @@ function parseStructuredFrontmatter(lines) {
     }
   }
   flushRequirementRef(requirementRefs, currentRef);
-  return { flat, requirementRefs, continuity };
+  return { flat, requirementRefs, continuity, numberingWaiver, numberingGate };
 }
 
 function parseIdentityBlock(lines, startIndex, endIndex = lines.length) {
@@ -324,6 +352,8 @@ function parseProposal(target, file, lines, frontmatter) {
   target.proposalMode = String(mergedFrontmatter.mode || '').trim().toLowerCase();
   target.requirementRefs = structured.requirementRefs;
   target.continuity = structured.continuity;
+  target.numberingWaiver = structured.numberingWaiver || {};
+  target.numberingGate = Boolean(structured.numberingGate);
   const changeId = String(mergedFrontmatter['change-id'] || '').trim().toUpperCase();
   if (changeId) {
     addEntity(
@@ -355,9 +385,20 @@ function parseProposal(target, file, lines, frontmatter) {
     const capabilityId = match[1].toUpperCase();
     const identity = parseIdentityBlock(lines, index + 1);
     if (structured.requirementRefs.length > 0) {
+      const expanded = [];
+      for (const ref of structured.requirementRefs) {
+        expanded.push(ref);
+        if (ref.feature_id) {
+          expanded.push({
+            system: ref.system,
+            object_type: 'feature',
+            external_id: ref.feature_id,
+          });
+        }
+      }
       identity.external_refs = [
         ...(identity.external_refs || []),
-        ...structured.requirementRefs,
+        ...expanded,
       ];
     }
     const slug = unwrapScalar(match[2]);
@@ -683,6 +724,8 @@ function parseChangeArtifacts(projectRoot, changeName, options = {}) {
     profile: 'simple',
     proposalMode: '',
     requirementRefs: [],
+    numberingWaiver: {},
+    numberingGate: false,
     continuity: {},
     artifacts: [],
     files: files.map((file) => ({ path: file.relativePath, content_hash: file.contentHash })),

package/skywalk-sdd/ontology/cli.cjs

@@ -10,6 +10,7 @@ const {
 } = require('./runtime.cjs');
 const { observeChangeArtifacts } = require('./artifact-observer.cjs');
 const { allocateIdentity } = require('./id.cjs');
+const externalKey = require('./external-key.cjs');
 
 function parseArgs(argv) {
   const result = { _: [] };
@@ -53,6 +54,7 @@ function showHelp() {
   node skywalk-sdd/ontology/cli.cjs identity  --delta-state=added
   node skywalk-sdd/ontology/cli.cjs identity  --delta-state=modified --entity-id=<uuid> --predecessor-version=<uuid>
   node skywalk-sdd/ontology/cli.cjs identity  --delta-state=unchanged --entity-id=<uuid> --version-id=<uuid>
+  node skywalk-sdd/ontology/cli.cjs external-key --validate <id> --type <requirement|feature|scenario>
   node skywalk-sdd/ontology/cli.cjs reconcile --project=. --change=<name> [--profile=...]
   node skywalk-sdd/ontology/cli.cjs check     --project=. --change=<name> [--profile=...]
   node skywalk-sdd/ontology/cli.cjs status    --project=. --change=<name>
@@ -73,6 +75,23 @@ function main(argv = process.argv.slice(2)) {
     console.log(JSON.stringify(allocateIdentity(args), null, 2));
     return;
   }
+  if (command === 'external-key') {
+    const id = args.validate || args._[1];
+    const type = args.type || args.t;
+    if (!id || !type) {
+      throw new Error('用法: external-key --validate <id> --type <requirement|feature|scenario>');
+    }
+    const result = externalKey.validate(id, type);
+    console.log(JSON.stringify({
+      ok: result.ok,
+      code: result.code,
+      message: result.message,
+      normalized: externalKey.normalize(id, type),
+      objectType: String(type).toLowerCase(),
+    }, null, 2));
+    if (!result.ok) process.exitCode = 1;
+    return;
+  }
   const projectRoot = path.resolve(args.project || '.');
   const changeName = args.change;
   if (!changeName) throw new Error('缺少 --change 参数');

package/skywalk-sdd/ontology/external-key.cjs

@@ -0,0 +1,159 @@
+'use strict';
+
+/**
+ * External key grammar for requirement / feature / scenario.
+ * Authority: kb-sdd docs/superpowers/specs/2026-07-24-external-numbering-kb-sdd-design.md §2.
+ * Regex and normalization MUST stay byte-for-byte aligned with kb-sdd ExternalKeyFormat.java.
+ */
+
+const REGEX = {
+  requirement: /^REQ-[A-Z][A-Z0-9]{1,7}-[0-9]{4}-[0-9]{3,6}$/,
+  feature: /^FEAT-[A-Z][A-Z0-9]{1,7}-[0-9]{3,6}$/,
+  scenario: /^REQ-[A-Z][A-Z0-9]{1,7}-[0-9]{4}-[0-9]{3,6}:SCN-[a-z0-9]+(-[a-z0-9]+)*-[0-9]{3}$/,
+};
+
+const SCENARIO_PARTS =
+  /^(REQ-[A-Z][A-Z0-9]{1,7}-[0-9]{4}-[0-9]{3,6}):SCN-([a-z0-9]+(?:-[a-z0-9]+)*)-([0-9]{3})$/;
+
+const SLUG_MAX_LEN = 40;
+const SCENARIO_KEY_MAX_LEN = 120;
+const SCN_SEQ_MAX = 999;
+
+const CODES = {
+  FORMAT_INVALID: 'EXTERNAL_KEY_FORMAT_INVALID',
+  SCOPE_MISMATCH: 'EXTERNAL_KEY_SCOPE_MISMATCH',
+  FEATURE_UNDECLARED: 'EXTERNAL_KEY_FEATURE_UNDECLARED',
+  SEQ_REUSED: 'EXTERNAL_KEY_SEQ_REUSED',
+  WAIVER_ACTIVE: 'NUMBERING_WAIVER_ACTIVE',
+};
+
+function normalizeObjectType(objectType) {
+  if (objectType == null || String(objectType).trim() === '') return null;
+  return String(objectType).trim().toLowerCase();
+}
+
+function normalize(id, objectType) {
+  if (id == null) return null;
+  const trimmed = String(id).trim();
+  if (!trimmed) return trimmed;
+  const type = normalizeObjectType(objectType);
+  if (type === 'scenario') {
+    const colon = trimmed.indexOf(':');
+    if (colon < 0) return trimmed.toUpperCase();
+    const reqPart = trimmed.slice(0, colon).trim().toUpperCase();
+    const rest = trimmed.slice(colon + 1).trim();
+    if (/^scn-/i.test(rest)) {
+      const afterScn = rest.slice(4);
+      const lastDash = afterScn.lastIndexOf('-');
+      if (lastDash > 0) {
+        const slug = afterScn.slice(0, lastDash).toLowerCase();
+        const seq = afterScn.slice(lastDash + 1);
+        return `${reqPart}:SCN-${slug}-${seq}`;
+      }
+    }
+    return `${reqPart}:${rest.toLowerCase()}`;
+  }
+  return trimmed.toUpperCase();
+}
+
+function validate(id, objectType) {
+  const type = normalizeObjectType(objectType);
+  if (!type || !REGEX[type]) {
+    return {
+      ok: false,
+      code: CODES.FORMAT_INVALID,
+      message: `未知 object_type，无法校验编号: ${objectType}`,
+    };
+  }
+  const normalized = normalize(id, type);
+  if (!normalized) {
+    return { ok: false, code: CODES.FORMAT_INVALID, message: 'external_id 为空' };
+  }
+  if (!REGEX[type].test(normalized)) {
+    return {
+      ok: false,
+      code: CODES.FORMAT_INVALID,
+      message: `编号格式不合规 (${type}): ${id} → ${normalized}`,
+    };
+  }
+  if (type === 'scenario') {
+    const parts = parseScenario(normalized);
+    if (!parts) {
+      return {
+        ok: false,
+        code: CODES.FORMAT_INVALID,
+        message: `场景键无法解析: ${normalized}`,
+      };
+    }
+    if (parts.slug.length > SLUG_MAX_LEN) {
+      return {
+        ok: false,
+        code: CODES.FORMAT_INVALID,
+        message: `场景 SLUG 超过 ${SLUG_MAX_LEN} 字符: ${parts.slug}`,
+      };
+    }
+    if (normalized.length > SCENARIO_KEY_MAX_LEN) {
+      return {
+        ok: false,
+        code: CODES.FORMAT_INVALID,
+        message: `场景键总长超过 ${SCENARIO_KEY_MAX_LEN} 字符`,
+      };
+    }
+  }
+  return { ok: true, code: null, message: null, normalized };
+}
+
+function parseScenario(key) {
+  const normalized = normalize(key, 'scenario');
+  if (!normalized) return null;
+  const match = SCENARIO_PARTS.exec(normalized);
+  if (!match) return null;
+  return {
+    requirementId: match[1],
+    slug: match[2],
+    seq: Number(match[3]),
+  };
+}
+
+function composeScenario(reqId, slug, seq) {
+  const req = normalize(reqId, 'requirement');
+  const normalizedSlug = String(slug || '').trim().toLowerCase();
+  const n = Number(seq);
+  if (!Number.isInteger(n) || n < 1 || n > SCN_SEQ_MAX) {
+    throw new Error(`SCN 序号必须在 1..${SCN_SEQ_MAX} 之间: ${seq}`);
+  }
+  const composed = `${req}:SCN-${normalizedSlug}-${String(n).padStart(3, '0')}`;
+  const result = validate(composed, 'scenario');
+  if (!result.ok) throw new Error(result.message);
+  return composed;
+}
+
+function nextScenarioSeq(reqId, usedKeys) {
+  const req = normalize(reqId, 'requirement');
+  let max = 0;
+  for (const key of usedKeys || []) {
+    const parts = parseScenario(key);
+    if (!parts) continue;
+    if (parts.requirementId === req) {
+      max = Math.max(max, parts.seq);
+    }
+  }
+  if (max >= SCN_SEQ_MAX) {
+    throw new Error(`SCN 序号已用尽 (999)，请回需求管理系统拆分需求: ${req}`);
+  }
+  return max + 1;
+}
+
+module.exports = {
+  REGEX,
+  CODES,
+  SLUG_MAX_LEN,
+  SCENARIO_KEY_MAX_LEN,
+  SCN_SEQ_MAX,
+  normalize,
+  validate,
+  parseScenario,
+  composeScenario,
+  nextScenarioSeq,
+  normalizeObjectType,
+};

package/skywalk-sdd/ontology/normalizer.cjs

@@ -82,6 +82,10 @@ function normalizeFacts(parsed) {
     profile: parsed.profile,
     proposal_mode: parsed.proposalMode || undefined,
     requirement_refs: Array.isArray(parsed.requirementRefs) ? parsed.requirementRefs : undefined,
+    numbering_waiver: parsed.numberingWaiver && Object.keys(parsed.numberingWaiver).length > 0
+      ? parsed.numberingWaiver
+      : undefined,
+    numbering_gate: parsed.numberingGate ? true : undefined,
     continuity: parsed.continuity && Object.keys(parsed.continuity).length > 0
       ? parsed.continuity
       : undefined,

package/skywalk-sdd/ontology/schema.cjs

@@ -107,6 +107,11 @@ const DIAGNOSTIC_CODES = Object.freeze({
   EXTERNAL_REF_INVALID: 'EXTERNAL_REF_INVALID',
   EXTERNAL_REF_TYPE_MISMATCH: 'EXTERNAL_REF_TYPE_MISMATCH',
   EXTERNAL_REF_CONFLICT: 'EXTERNAL_REF_CONFLICT',
+  EXTERNAL_KEY_FORMAT_INVALID: 'EXTERNAL_KEY_FORMAT_INVALID',
+  EXTERNAL_KEY_SCOPE_MISMATCH: 'EXTERNAL_KEY_SCOPE_MISMATCH',
+  EXTERNAL_KEY_FEATURE_UNDECLARED: 'EXTERNAL_KEY_FEATURE_UNDECLARED',
+  EXTERNAL_KEY_SEQ_REUSED: 'EXTERNAL_KEY_SEQ_REUSED',
+  NUMBERING_WAIVER_ACTIVE: 'NUMBERING_WAIVER_ACTIVE',
   CONTINUITY_DECISION_REQUIRED: 'CONTINUITY_DECISION_REQUIRED',
   CONTINUITY_IDENTITY_MISMATCH: 'CONTINUITY_IDENTITY_MISMATCH',
 });

package/skywalk-sdd/ontology/traceability-validator.cjs

@@ -453,8 +453,94 @@ function validateContinuityAndExternalRefs(facts, diagnostics, options = {}) {
     }
   }
 
+  const {
+    validate,
+    normalize,
+    parseScenario,
+  } = require('./external-key.cjs');
+
+  // 仅当 frontmatter 显式出现 requirement-refs / numbering-waiver 时启用入场门禁
+  // （新模板默认带 requirement-refs；旧夹具无该节则不强制）
+  const numberingDeclared = Boolean(facts.numbering_gate)
+    || (facts.numbering_waiver && typeof facts.numbering_waiver === 'object');
+  const requirementRefs = Array.isArray(facts.requirement_refs) ? facts.requirement_refs : [];
+  const waiverReason = String(
+    (facts.numbering_waiver && (facts.numbering_waiver.reason || facts.numbering_waiver.Reason)) || '',
+  ).trim();
+  if (numberingDeclared) {
+    if (requirementRefs.length === 0 && !waiverReason) {
+      diagnostics.push(diagnostic(
+        DIAGNOSTIC_CODES.CONTINUITY_DECISION_REQUIRED,
+        'error',
+        '缺少格式合规的 requirement-refs，且未提供 numbering-waiver.reason',
+        {
+          file: 'proposal.md',
+          suggestion: '申报 REQ 号，或填写 numbering-waiver.reason（探索性/纯内部重构）',
+        },
+      ));
+    }
+    if (requirementRefs.length === 0 && waiverReason) {
+      diagnostics.push(diagnostic(
+        DIAGNOSTIC_CODES.NUMBERING_WAIVER_ACTIVE,
+        'warning',
+        `编号豁免生效：${waiverReason}（本轮不种桥）`,
+        { file: 'proposal.md' },
+      ));
+    }
+    if (requirementRefs.length > 0 && waiverReason) {
+      diagnostics.push(diagnostic(
+        DIAGNOSTIC_CODES.EXTERNAL_KEY_FORMAT_INVALID,
+        'error',
+        'numbering-waiver 与非空 requirement-refs 互斥',
+        { file: 'proposal.md', suggestion: '清空其一' },
+      ));
+    }
+  }
+
+  const declaredReqIds = new Set();
+  const featureByReq = new Map();
+  for (const ref of requirementRefs) {
+    const objectType = String(ref.object_type || 'requirement').toLowerCase();
+    const format = validate(ref.external_id, objectType);
+    if (!format.ok) {
+      diagnostics.push(diagnostic(
+        DIAGNOSTIC_CODES.EXTERNAL_KEY_FORMAT_INVALID,
+        'error',
+        format.message,
+        { file: 'proposal.md', suggestion: '回需求管理系统核实/换发编号，禁止改写' },
+      ));
+      continue;
+    }
+    const normalizedReq = normalize(ref.external_id, objectType);
+    if (objectType === 'requirement') {
+      declaredReqIds.add(normalizedReq);
+      if (ref.feature_id_invalid) {
+        diagnostics.push(diagnostic(
+          DIAGNOSTIC_CODES.EXTERNAL_KEY_FORMAT_INVALID,
+          'error',
+          `feature-id 不合规: ${ref.feature_id_invalid}`,
+          { file: 'proposal.md', suggestion: '回需求管理系统核实 FEAT 号，禁止静默丢弃' },
+        ));
+      } else if (ref.feature_id) {
+        if (featureByReq.has(normalizedReq) && featureByReq.get(normalizedReq) !== ref.feature_id) {
+          diagnostics.push(diagnostic(
+            DIAGNOSTIC_CODES.EXTERNAL_KEY_FEATURE_UNDECLARED,
+            'error',
+            `同一 Change 内同一 REQ 申报了多个 feature-id: ${normalizedReq}`,
+            { file: 'proposal.md' },
+          ));
+        }
+        featureByReq.set(normalizedReq, normalize(ref.feature_id, 'feature'));
+      }
+    }
+  }
+
   const bindingKeys = new Map();
+  const scenarioKeysInChange = new Set();
+  const removedScenarioKeys = new Set();
   for (const entity of facts.entities || []) {
+    const declaredFeatures = new Set();
+    const featureBindings = new Set();
     for (const ref of entity.external_refs || []) {
       const objectType = String(ref.object_type || '').toLowerCase();
       const allowedTypes = allowed[objectType];
@@ -475,6 +561,59 @@ function validateContinuityAndExternalRefs(facts, diagnostics, options = {}) {
           { ...sourceContext(entity), entity_id: entity.id },
         ));
       }
+      const format = validate(ref.external_id, objectType);
+      if (!format.ok) {
+        diagnostics.push(diagnostic(
+          DIAGNOSTIC_CODES.EXTERNAL_KEY_FORMAT_INVALID,
+          'error',
+          `${format.message} (${entity.id})`,
+          {
+            ...sourceContext(entity),
+            entity_id: entity.id,
+            suggestion: '编号不合规回需求系统换发；场景键回 opsx-spec 修正',
+          },
+        ));
+      }
+      if (ref.feature_id) {
+        const featureFormat = validate(ref.feature_id, 'feature');
+        if (!featureFormat.ok) {
+          diagnostics.push(diagnostic(
+            DIAGNOSTIC_CODES.EXTERNAL_KEY_FORMAT_INVALID,
+            'error',
+            `requirement.feature_id 不合规: ${featureFormat.message} (${entity.id})`,
+            { ...sourceContext(entity), entity_id: entity.id },
+          ));
+        } else {
+          declaredFeatures.add(normalize(ref.feature_id, 'feature'));
+        }
+      }
+      if (objectType === 'feature') {
+        featureBindings.add(normalize(ref.external_id, 'feature'));
+      }
+      if (objectType === 'scenario') {
+        const normalizedScenario = normalize(ref.external_id, 'scenario');
+        const parts = parseScenario(normalizedScenario);
+        if (parts && declaredReqIds.size > 0 && !declaredReqIds.has(parts.requirementId)) {
+          diagnostics.push(diagnostic(
+            DIAGNOSTIC_CODES.EXTERNAL_KEY_SCOPE_MISMATCH,
+            'error',
+            `场景键 REQ 前缀不在 frontmatter requirement-refs 申报集合: ${normalizedScenario}`,
+            { ...sourceContext(entity), entity_id: entity.id },
+          ));
+        }
+        if (scenarioKeysInChange.has(normalizedScenario)) {
+          diagnostics.push(diagnostic(
+            DIAGNOSTIC_CODES.EXTERNAL_KEY_SEQ_REUSED,
+            'error',
+            `本 Change 内 SCN 键重复: ${normalizedScenario}`,
+            { ...sourceContext(entity), entity_id: entity.id },
+          ));
+        }
+        scenarioKeysInChange.add(normalizedScenario);
+        if (String(entity.delta_state || '').toLowerCase() === 'removed') {
+          removedScenarioKeys.add(normalizedScenario);
+        }
+      }
       const key = `${ref.system}|${objectType}|${ref.external_id}|${entity.anchor_id || entity.id}`;
       const prior = bindingKeys.get(key);
       if (prior && prior !== entity.entity_id) {
@@ -492,6 +631,42 @@ function validateContinuityAndExternalRefs(facts, diagnostics, options = {}) {
         bindingKeys.set(key, entity.entity_id);
       }
     }
+    for (const featureId of featureBindings) {
+      if (!declaredFeatures.has(featureId)) {
+        diagnostics.push(diagnostic(
+          DIAGNOSTIC_CODES.EXTERNAL_KEY_FEATURE_UNDECLARED,
+          'error',
+          `feature 绑定无法与同实体 requirement.feature_id 配对: ${featureId} (${entity.id})`,
+          { ...sourceContext(entity), entity_id: entity.id },
+        ));
+      }
+    }
+    for (const featureId of declaredFeatures) {
+      if (!featureBindings.has(featureId)) {
+        diagnostics.push(diagnostic(
+          DIAGNOSTIC_CODES.EXTERNAL_KEY_FEATURE_UNDECLARED,
+          'error',
+          `requirement 申报了 feature_id 但缺少对应 feature 绑定: ${featureId} (${entity.id})`,
+          { ...sourceContext(entity), entity_id: entity.id },
+        ));
+      }
+    }
+  }
+
+  for (const entity of facts.entities || []) {
+    if (String(entity.delta_state || '').toLowerCase() === 'removed') continue;
+    for (const ref of entity.external_refs || []) {
+      if (String(ref.object_type || '').toLowerCase() !== 'scenario') continue;
+      const key = normalize(ref.external_id, 'scenario');
+      if (removedScenarioKeys.has(key) && String(entity.delta_state || '').toLowerCase() !== 'removed') {
+        diagnostics.push(diagnostic(
+          DIAGNOSTIC_CODES.EXTERNAL_KEY_SEQ_REUSED,
+          'error',
+          `复用了 removed 墓碑 SCN 号: ${key}`,
+          { ...sourceContext(entity), entity_id: entity.id },
+        ));
+      }
+    }
   }
 }
 

package/templates/openspec/proposal.md

@@ -7,11 +7,14 @@ delta-state: "added"
 predecessor-version: "" # added 留空；modified/removed 指向直接前序版本
 mode: "" # full=分 Capability 产物，simple=根目录精简产物
 test-strategy: "" # tdd=测试先行, impl-first=实现优先, none=无测试
-# 外部需求键（首轮冷启动也建议写入，便于 ingest 种桥）
+# 外部需求键（默认必填 ≥1 个合规 REQ；探索性/纯内部重构可走 numbering-waiver）
 requirement-refs:
   - system: requirement-mgmt
     object-type: requirement
-    external-id: REQ-<DOMAIN>-<NNN>
+    external-id: REQ-<DOMAIN>-<YEAR>-<SEQ>   # 例 REQ-FI-2024-001
+    feature-id: FEAT-<DOMAIN>-<SEQ>          # 可选，需求所属功能（需求系统权威）
+# numbering-waiver:
+#   reason: "探索性原型，本轮不种桥"
 # Continuity：字段一律来自知识库 resolve，禁止本地 archive 文件夹名
 continuity:
   kind: new # iteration | similar-reference | new

package/templates/openspec/spec.md

@@ -34,7 +34,7 @@ capability-id: "CAP-<CAPABILITY>" # 必须与 proposal.md 中的 Capability ID
 - **version-id**: <UUID>
 - **delta-state**: added
 - **predecessor-version**: 无
-- **external-ref**: requirement-mgmt:scenario:REQ-<DOMAIN>-<NNN>:SCN-<slug>
+- **external-ref**: requirement-mgmt:scenario:REQ-<DOMAIN>-<YEAR>-<SEQ>:SCN-<slug>-<NNN>
 - **当** <!-- 触发条件 -->
 - **预期** <!-- 预期结果 -->
 
@@ -43,7 +43,7 @@ capability-id: "CAP-<CAPABILITY>" # 必须与 proposal.md 中的 Capability ID
 - **version-id**: <UUID>
 - **delta-state**: added
 - **predecessor-version**: 无
-- **external-ref**: requirement-mgmt:scenario:REQ-<DOMAIN>-<NNN>:SCN-<slug>
+- **external-ref**: requirement-mgmt:scenario:REQ-<DOMAIN>-<YEAR>-<SEQ>:SCN-<slug>-<NNN>
 - **当** <!-- 触发条件 -->
 - **预期** <!-- 预期结果 -->
 
@@ -63,7 +63,7 @@ capability-id: "CAP-<CAPABILITY>" # 必须与 proposal.md 中的 Capability ID
 - **version-id**: <新 UUID>
 - **delta-state**: <modified|added>
 - **predecessor-version**: <modified 时填写；added 为无>
-- **external-ref**: requirement-mgmt:scenario:REQ-<DOMAIN>-<NNN>:SCN-<slug>
+- **external-ref**: requirement-mgmt:scenario:REQ-<DOMAIN>-<YEAR>-<SEQ>:SCN-<slug>-<NNN>
 - **当** <!-- 触发条件 -->
 - **预期** <!-- 预期结果 -->
 

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

@@ -211,6 +211,7 @@ g. **继续下一个层级** — 重新检查 DAG，找出依赖已满足的下
 > 合理化预防表见 opsx-tdd-core/SKILL.md §7
 > REFACTOR 检查点见 opsx-tdd-rules/rules/refactor-checklist.md
 > 异常路径覆盖门禁见 opsx-tdd-rules/rules/exception-path-coverage.md
+> TDD 节奏校验（执行后校验）见 `./checklist.md` §5e.1
 
 **【S2.1 RED 测试质量标准】**（test-strategy=tdd 时强制）：
 
@@ -282,6 +283,7 @@ g. **继续下一个层级** — 重新检查 DAG，找出依赖已满足的下
 - **⛔ 编译检查门禁**：每完成一个任务后必须运行编译检查，编译失败禁止标记已完成。
 - **⛔ 测试执行门禁**：根据 `test-strategy` 决定（tdd=强制, impl-first=强制补跑, none=跳过）；须真实执行并留 telemetry。${HOOK_GATE_DESCRIPTION}
 - **⛔ 必须实时更新任务状态**：每完成一个任务立即改 tasks.md，两种格式同步。
+- **⛔ apply 结束前 checkbox 全量同步校验**：`stage_end` 前对比 telemetry `task_update` 记录数与 tasks.md `[x]` 数量，不一致则补齐（见 `./checklist.md` §5f.1）。
 - **⛔ task_update 后必须验证 checkbox 已更新**：执行 `check-task` 确认 tasks.md 对应行已变更；未更新则手动修改。
 - **⛔ TDD RED→GREEN 严格串行**：不适用同层并行派发；RED-N 确认失败后必须执行中断声明再进入 GREEN-N；GREEN 完成后必须通过 Scope 门禁再进入下一个 RED。
 - **Git 只读策略**：禁止为了度量自动初始化 Git、创建分支或提交 commit；非 Git 项目用 `vcs_mode=no-git` 继续执行。
@@ -298,7 +300,7 @@ g. **继续下一个层级** — 重新检查 DAG，找出依赖已满足的下
 
 ## 渐进披露
 
-- Read `checklist.md` 仅在执行 apply 需要校验门禁/自检时 — 含 §1.2 Check 门禁检查点、§5d/§5e 编译/测试门禁自检、§6.0 单元测试真实执行自检、§6.1 worktree 收尾前置条件、Guardrails ⛔ 强制项勾选表。
+- Read `checklist.md` 仅在执行 apply 需要校验门禁/自检时 — 含 §1.2 Check 门禁检查点、§5d/§5e 编译/测试门禁自检、§5e.1 TDD 节奏校验、§5f.1 checkbox 全量同步校验、§6.0 单元测试真实执行自检、§6.1 worktree 收尾前置条件、Guardrails ⛔ 强制项勾选表。
 - Read `reference.md` 仅在需要参考详细模板时 — 含 📊 Telemetry 命令模板（start/end/task_update/ai_adoption_review/worktree_finish）、§1.5 worktree 全套策略（Step 0.1-3 + record-base + 多 cap 合并顺序）、§5c 子代理派发、§5.1 AI 产出快照、§6.0 单元测试、§6.1 worktree 收尾脚本。
 - `implementer-prompt.md` 为子代理派发提示模板（§5c 派发时组合 tasks/design/overview 上下文使用）。
 - `worktree-setup.md` 为 worktree 快速参考（§1.5 策略的精简版，与 reference.md §1.5 完整版并存：reference=完整策略，worktree-setup=快速参考）。

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

@@ -47,6 +47,11 @@ description: opsx-apply 的阶段强制检查点与自检清单。仅在执行 a
 > 不在此内联复制，以 opsx-tdd-core/checklist.md §A 为唯一真相源。
 > 额外补充：REFACTOR 任务还需执行 `opsx-tdd-rules/rules/refactor-checklist.md`（7 项重构检查点）。
 
+⛔ **TDD 节奏校验**（RED→GREEN 严格串行的执行后校验）：
+- [ ] 连续的 RED-N `task_update` 与 GREEN-N `task_update` 之间有可验证的执行间隔（建议 >60 秒），若时间戳差距过小视为批量执行信号
+- [ ] 每对 RED→GREEN 之间已执行 🔴 中断声明（`🔴 RED-N 确认失败，原因：XXX。现在进入 GREEN-N`）
+- [ ] 若同层有多个 RED→GREEN 对，确认是逐对完成而非一次性编写多个 RED 再一次性实现多个 GREEN
+
 ### §5e.2 RED 测试质量门禁（仅 test-strategy=tdd 时，RED 任务完成后强制检查）
 
 ⛔ 核心原则（引用 opsx-tdd-quality/SKILL.md §2）：Mock 边界，不 Mock 行为
@@ -79,6 +84,15 @@ description: opsx-apply 的阶段强制检查点与自检清单。仅在执行 a
 - [ ] 记录任务级 Telemetry（`task_update`，`--task-id=<TASK-ID>` 必填，否则 E4 指标无法计算）；TDD 测试骨架任务须在 `--details-json` 带 `"task_kind":"test-skeleton"`（P3，避免红灯误判拉低 E4）
 - [ ] ⛔ **task_update 后必须验证 checkbox 已更新**：执行 `node skywalk-sdd/index.cjs check-task --project=. --change=<变更名称> --task-id=<TASK-ID>` 确认 tasks.md 中对应行已从 `- [ ]` 变为 `- [x]`；若未更新，手动修改 tasks.md 并报告
 
+### §5f.1 apply 结束前 checkbox 全量同步校验
+
+> ⛔ 在 `stage_end` telemetry 记录前必须执行此校验，防止任务状态滞后到 archive 阶段。
+
+- [ ] 对比 telemetry `task_update` 记录的已完成任务数与 tasks.md 中 `[x]` 数量，不一致则补齐
+- [ ] tasks.md 中所有 `- [ ]` / `- [x]` 与 `**状态**: [ ]` / `[x]` 两种格式已同步
+- [ ] 手动验证清单（如有）已勾选
+- [ ] 文档更新项（如有）已完成或显式标注推迟
+
 ---
 
 ## §6.0 单元测试真实执行自检（`test-strategy` 非 `none`）
@@ -114,8 +128,10 @@ description: opsx-apply 的阶段强制检查点与自检清单。仅在执行 a
 - [ ] ⛔ **测试执行门禁**：根据 `test-strategy` 决定（tdd=强制, impl-first=强制补跑, none=跳过）；须真实执行并留 telemetry，`sdd-apply-test-gate` 校验非占位数据
 - [ ] ⛔ **RED 测试质量门禁**：见 §5e.2（引用 opsx-tdd-quality + opsx-tdd-anti-patterns，不在此内联复制）
 - [ ] ⛔ **必须实时更新任务状态**：每完成一个任务立即改 tasks.md，两种格式（`- [ ]`→`- [x]` 与 `**状态**: [ ]`→`[x]`）同步
+- [ ] ⛔ **apply 结束前 checkbox 全量同步校验**：见 §5f.1，`stage_end` 前对比 telemetry `task_update` 记录数与 tasks.md `[x]` 数量
 - [ ] ⛔ **task_update 后必须验证 checkbox 已更新**：执行 `check-task` 确认 tasks.md 对应行已变更；未更新则手动修改
 - [ ] ⛔ **TDD RED→GREEN 严格串行**：不适用同层并行派发；RED-N 确认失败后必须执行中断声明再进入 GREEN-N；GREEN 完成后必须通过 Scope 门禁再进入下一个 RED
+- [ ] ⛔ **TDD 节奏校验**：见 §5e.1，连续 RED-N/GREEN-N 的 `task_update` 时间戳须有可验证间距
 - [ ] **Git 只读策略**：禁止为了度量自动初始化 Git、创建分支或提交 commit；非 Git 项目用 `vcs_mode=no-git` 继续执行
 - [ ] ⛔ **Step 0.1 隔离校验必做**：建 worktree / 建议分支名前必须完成 proposal + 跨 cap spec 依赖校验并输出报告；未通过不得按 full 并行策略拆 `kld-sdd/<change>/<cap>`
 - [ ] **Worktree 为加速手段，非必选项**：校验通过且解耦方可多 worktree；有依赖或共享修改面则串行

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

@@ -97,6 +97,10 @@ openspec list
 - [ ] spec.md 的需求项在 design.md 中 100% 被覆盖
 - [ ] design.md 的设计点在 tasks.md 中 100% 被拆解
 - [ ] 跨文档引用路径正确
+- [ ] ⛔ **CON 覆盖一致性**：spec.md 中每个 CON 在 tasks.md 中有对应验证任务或显式声明间接覆盖；tasks.md 声明"100% 覆盖 CON"时必须可追溯
+- [ ] ⛔ **安全/审计要求覆盖一致性**：spec.md §5.x 中的安全与审计要求在 tasks.md 中有对应任务或显式声明推迟
+- [ ] ⛔ **AC 变体覆盖一致性**：spec.md 中含"或"条件的 AC 场景，其 RED 任务验收标准须列出所有变体的测试方法（规则见 `opsx-tdd-rules/rules/multi-validation-split.md` §AC 内"或"条件变体覆盖）
+- [ ] ⛔ **tasks.md §4.x 验证方式表内部一致性**：§4.x 验证方式表中的测试注解/配置与任务实现步骤中的声明一致
 
 #### 4.3 算法正确性检查
 
@@ -216,7 +220,7 @@ node skywalk-sdd/log.cjs record --type=conformance_review --command=check --proj
 
 ---
 
-## Continuity / external_ref 确定性门禁
+## Continuity / external_ref / 编号确定性门禁
 
 `opsx-check` **不联网提问**。Agent 应在 propose/spec 已问完；本阶段只验证并入既有 apply 前门禁：
 
@@ -224,6 +228,13 @@ node skywalk-sdd/log.cjs record --type=conformance_review --command=check --proj
 - 已写 spec 的 Capability：场景 `external-ref` 与 `continuity-resolution.json` 决议一致；同 key+同锚点未偷偷换 entity_id
 - 用户选「原对象」却仍用新 id、或选「新对象」却仍共用旧锚点 → 失败（`CONTINUITY_IDENTITY_MISMATCH` / `EXTERNAL_REF_CONFLICT`）
 - 决议缺失 / pending / 与产物不一致 → `CONTINUITY_DECISION_REQUIRED`
+- **编号诊断码**（并入五维报告与 apply gate）：
+  - `EXTERNAL_KEY_FORMAT_INVALID` — external_id / feature_id 不合规
+  - `EXTERNAL_KEY_SCOPE_MISMATCH` — 场景键 REQ 前缀不在 `requirement-refs`
+  - `EXTERNAL_KEY_FEATURE_UNDECLARED` — feature↔requirement.`feature_id` 配对断裂
+  - `EXTERNAL_KEY_SEQ_REUSED` — 本 Change 内 SCN 重复或复用 removed 墓碑号
+  - `NUMBERING_WAIVER_ACTIVE`（warning）— 豁免生效，本轮不种桥
+- `requirement-refs` 为空且无有效 waiver → `CONTINUITY_DECISION_REQUIRED` 级阻断
 - CI/非交互：失败即非零退出并打印修复说明，不挂起等待输入
 
 ## 本体语义关系门禁

package/templates/skills/kld-sdd/opsx-check/checklist.md

@@ -36,6 +36,13 @@ description: "opsx-check 阶段日志自检清单 — 仅在 check 自检时读
 - [ ] 完整性、一致性、算法正确性、可执行性、TDD合规性（仅test-strategy=tdd时）五维均已输出
 - [ ] 报告问题对应修复建议（spec/design/task）
 
+## D2. 一致性补充检查（SKILL.md §4.2 扩展）
+
+- [ ] **CON 覆盖**：spec.md 中每个 CON 在 tasks.md 中有对应验证任务或显式声明间接覆盖
+- [ ] **安全/审计要求覆盖**：spec.md §5.x 中的安全与审计要求在 tasks.md 中有对应任务或显式声明推迟
+- [ ] **AC 变体覆盖**：spec.md 中含"或"条件的 AC 场景，其 RED 任务验收标准列出所有变体的测试方法（引用 `opsx-tdd-rules/rules/multi-validation-split.md`）
+- [ ] **§4.x 验证方式表内部一致性**：tasks.md §4.x 验证方式表中的测试注解/配置与任务实现步骤中的声明一致
+
 ## E. TDD 合规性检查（仅 test-strategy=tdd 时）
 
 ⛔ 执行 `opsx-tdd-core/checklist.md` §B（11 项）逐项检查。

package/templates/skills/kld-sdd/opsx-kb-ingest/SKILL.md

@@ -5,24 +5,10 @@ description: >-
   (archive:ingest scope). Prompts for API key and multi-selects spaces/KBs into
   local skill state. Supports upload, job status query, job list, and retry.
   Use when ingesting new or updated knowledge archives into the ontology KB.
-argument-hint: "[path-to-archive.zip]"
-license: MIT
-compatibility: Requires Engineering KB API (API Key with archive:ingest).
-metadata:
-  author: sdd-team
-  version: "1.0"
-  source: "kb-sdd/skills/opsx-kb-ingest"
-allowed-tools:
-  - Bash
-  - Read
-  - Write
-  - Edit
 ---
 
 # 本体知识库 · 入库
 
-> **部署说明**：本技能随 `kld-sdd-init` 安装到项目 skills 目录。权威源在工程知识库仓 `skills/opsx-kb-ingest`；`opsx-archive` **硬依赖**本技能完成收尾入库。
-
 只负责**入库**（zip 上传）。鉴权只用 **API Key**（`Authorization: Bearer sk_sdd_…`），**禁止**走手机号登录。
 
 > 控制台知识库页另有浮动 Ontology Agent（会话登录 + SSE）；本 Skill 仍走 API Key，二者分开。
@@ -127,6 +113,9 @@ curl -sS -X POST "$API/v1/spaces/$SPACE_ID/knowledge-bases/$KB_ID/ingestions/$JO
 - object_type 与实体类型匹配：`requirement`/`feature`→Capability；`scenario`→SpecificationStatement|AcceptanceCriterion
 - 包内无重复 `(external key, entity_id)` 绑定对
 - `project_id` / `spaceKey` 既有规则保留
+- **编号格式**：三条正则（见 reference）+ 场景 SLUG≤40 / 键总长≤120；先归一化再匹配
+- **场景作用域**：scenario 键的 REQ 前缀必须出现在同包 requirement 绑定集合
+- **功能配对**：同实体每条 feature 绑定必须能与某 requirement 条目的 `feature_id` 精确配对；反向同理
 
 详细字段说明 → [reference.md](reference.md)。
 
@@ -160,6 +149,16 @@ curl -sS -X POST "$API/v1/spaces/$SPACE_ID/knowledge-bases/$KB_ID/ingestions/$JO
    - **改为新锚点**：回到 kld-sdd，分配新锚点与新 entity_id，重新 check → 归档 → 入库
 3. **禁止**在 KB 内现场改绑或解绑。
 
+若编号门禁失败：
+
+| errorCode | 指引 |
+|-----------|------|
+| `EXTERNAL_REFERENCE_FORMAT_INVALID` | 编号不合规 → **回需求管理系统换发**；不得手改编号硬闯 |
+| `EXTERNAL_REFERENCE_SCOPE_MISMATCH` | 场景键 REQ 前缀不在申报集合 → 回 kld-sdd spec 修正 external-ref |
+| `EXTERNAL_REFERENCE_FEATURE_UNBOUND` | feature↔requirement.`feature_id` 配对断裂 → 回 propose/archive 修正线缆字段 |
+
+**禁止**手改包内编号绕过门禁。
+
 **硬规则**
 
 - 无 `apiKey` 不得猜密钥、不得改走 login。

package/templates/skills/kld-sdd/opsx-kb-ingest/reference.md

@@ -141,8 +141,21 @@ POST {base}/ingestions/{jobId}/retry
 | `EXTERNAL_REF_CONFLICT` | 同外部键+同锚点已绑不同 entity_id；整包回滚；见 `report.details` |
 | `EXTERNAL_REFERENCE_TYPE_MISMATCH` | 包内 object_type 与实体类型不匹配 |
 | `EXTERNAL_REFERENCE_DUPLICATE_IN_PACKAGE` | 包内重复 `(external key, entity_id)` |
+| `EXTERNAL_REFERENCE_FORMAT_INVALID` | 编号归一化后不合规（含 requirement.`feature_id`）；回需求系统换发 |
+| `EXTERNAL_REFERENCE_SCOPE_MISMATCH` | 场景键 REQ 前缀不在同包 requirement 集合；回 kld-sdd spec 修正 |
+| `EXTERNAL_REFERENCE_FEATURE_UNBOUND` | feature 绑定与 requirement.`feature_id` 无法配对；回 propose/archive |
 | `FACTS_SCHEMA_UNSUPPORTED` | canonical-facts schema 非 v1/v2 |
 
+### 编号正则（与 KB 设计 §2 / ExternalKeyFormat 一致）
+
+```text
+requirement: ^REQ-[A-Z][A-Z0-9]{1,7}-[0-9]{4}-[0-9]{3,6}$
+feature:     ^FEAT-[A-Z][A-Z0-9]{1,7}-[0-9]{3,6}$
+scenario:    ^REQ-[A-Z][A-Z0-9]{1,7}-[0-9]{4}-[0-9]{3,6}:SCN-[a-z0-9]+(-[a-z0-9]+)*-[0-9]{3}$
+```
+
+requirement 条目可选 `feature_id`（FEAT 文法）；配对关系随线缆走，KB 不反查 frontmatter。
+
 ### `EXTERNAL_REF_CONFLICT` 的 report.details
 
 ```json

package/templates/skills/kld-sdd/opsx-ontology-query/SKILL.md

@@ -5,24 +5,10 @@ description: >-
   entity/impact/ontology-view). Prompts for API key and multi-selects spaces/KBs into
   local skill state. Use when looking up Spec/design facts, Spec reuse, impact, or
   citation-backed answers from the ontology KB.
-argument-hint: "[query or continuity intent]"
-license: MIT
-compatibility: Requires Engineering KB API (API Key with context:read).
-metadata:
-  author: sdd-team
-  version: "1.0"
-  source: "kb-sdd/skills/opsx-ontology-query"
-allowed-tools:
-  - Bash
-  - Read
-  - Write
-  - Edit
 ---
 
 # 本体知识库 · 查询
 
-> **部署说明**：本技能随 `kld-sdd-init` 安装到项目 skills 目录。权威源在工程知识库仓 `skills/opsx-ontology-query`；`opsx-propose` / `opsx-spec` 等流程技能**硬依赖**本技能，缺失时不得用本地 archive 兜底。
-
 只负责**查**。鉴权只用 **API Key**（`Authorization: Bearer sk_sdd_…`），**禁止**走手机号登录。
 
 > 控制台知识库页另有浮动 Ontology Agent（会话登录 + SSE）；本 Skill 仍走 API Key，二者分开。
@@ -124,6 +110,31 @@ curl -sS -X POST "$API/v1/spaces/$SPACE_ID/knowledge-bases/$KB_ID/entities/resol
 
 命中时关注：`resolution=LINK_EXISTING` 且 `inheritanceAllowed=true`（可继承 n）；`removedBindingCount`（已失效绑定 m）；`matchType=HISTORICAL_ONLY` 表示仅有失效绑定，不可继承。
 
+**按功能号圈能力（propose 前）**
+
+```bash
+curl -sS -X POST "$API/v1/spaces/$SPACE_ID/knowledge-bases/$KB_ID/entities/resolve" \
+  -H "Authorization: Bearer $API_KEY" -H "Content-Type: application/json" \
+  -d '{
+    "externalSystem":"requirement-mgmt",
+    "externalObjectType":"feature",
+    "externalId":"FEAT-FI-012",
+    "entityType":"Capability"
+  }'
+```
+
+展示该功能下存活 / 失效能力清单，辅助勾选本次 CAP 范围；此查询只作范围参考，不改变 Continuity 判定优先级。
+
+### 编号文法速查（权威在 KB 仓设计 §2）
+
+```text
+requirement: ^REQ-[A-Z][A-Z0-9]{1,7}-[0-9]{4}-[0-9]{3,6}$
+feature:     ^FEAT-[A-Z][A-Z0-9]{1,7}-[0-9]{3,6}$
+scenario:    ^REQ-…:SCN-[a-z0-9]+(-[a-z0-9]+)*-[0-9]{3}$
+```
+
+归一化：trim；REQ/FEAT 段大写；SCN slug 小写。编号五律摘要：REQ/FEAT 仅需求系统铸号；SCN 由 kld-sdd/opsx-spec 铸号；编号≠身份；归属权威在需求系统；历史绑定 append-only。
+
 **match-requirement**
 
 ```bash
@@ -152,7 +163,7 @@ curl -sS -X POST "$API/v1/spaces/$SPACE_ID/knowledge-bases/$KB_ID/context/match-
 
 ### 命中
 1. **{displayName}**（{entityType}）@ {kbName}
-   - id / version / matchType / externalRefs …
+   - id / version / matchType / externalRefs（归一化形态）…
    - 若外部键命中：可继承 n / 已失效绑定 m
 ```
 

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

@@ -162,13 +162,21 @@ openspec instructions proposal --change "<name>" --json
 
 > 完整性检查（问题描述/目标/模块/约束 4 项）与缺失补充机制见 `./checklist.md`「§6 需求完整性检查」。发现缺失时主动询问用户补充。
 
-### 6.5 【Continuity】需求 / Capability 身份（只到 CAP，不做场景）
+### 6.5 【编号入场 + Continuity】需求 / Capability 身份（只到 CAP，不做场景）
 
-在创建变更目录之后、写 proposal 能力列表之前（或紧接 CAP 编号分配前）：
+在创建变更目录之后、写 proposal 能力列表之前（或紧接 CAP 编号分配前）。**验号必须在 resolve 之前**：
 
-1. 提取 / 询问外部需求号 `REQ-*`（没有则问一次）。
-2. **先加载依赖技能**：确认 `${AGENT_SKILL_DIR}/opsx-ontology-query/SKILL.md`（或当前编辑器等价 skills 路径）存在并 Read；按该技能完成 API Key / 空间与 KB 选择（写入其 `.local/state.json`）。未安装则停止本步。
-3. 调用知识库 **`opsx-ontology-query`**（权威）；可用薄封装，但契约以该技能为准：
+1. 收集 REQ 号（含可选 `feature-id`）；没有则问一次。
+2. 逐个验号（确定性入口，禁止肉眼判正则）：
+```bash
+node skywalk-sdd/ontology/cli.cjs external-key --validate "<REQ-...>" --type requirement
+# 若有 feature-id：
+node skywalk-sdd/ontology/cli.cjs external-key --validate "<FEAT-...>" --type feature
+```
+   - REQ/FEAT 不合规 → **拒绝进入 resolve**，告知「编号不合规，请回需求管理系统核实/换发」；Agent 不得猜测、补位、改写。
+   - 用户明确说「没有外部需求号」→ 走 `numbering-waiver.reason`（必填理由）；`requirement-refs` 必须为空；提示本轮不种桥。
+3. **先加载依赖技能**：确认 `${AGENT_SKILL_DIR}/opsx-ontology-query/SKILL.md` 存在并 Read；按该技能完成 API Key / 空间与 KB 选择。未安装则停止本步。
+4. 验号通过后才 resolve：
 ```bash
 node skywalk-sdd/context-client.cjs --mode=resolve \
   --external-system=requirement-mgmt \
@@ -178,11 +186,12 @@ node skywalk-sdd/context-client.cjs --mode=resolve \
   --space-id="$ENGINEERING_KB_SPACE_ID" \
   --kb-id="$ENGINEERING_KB_KB_ID"
 ```
-4. 按 KB 结果确认 Continuity：`iteration` / `similar-reference` / `new`；勾选本次涉及的 CAP。
-5. 写入 proposal frontmatter：`requirement-refs` + `continuity`（字段来自 KB：`kb-space-id` / `kb-id` / `base-capabilities[].entity-id` / `current-version-id`）。**禁止**写本地 archive 文件夹名作为 `base-archive`。
-6. CAP 级「同 key + 同锚点、不同 entity_id」当场问 A/B/C；决议写入 `openspec/changes/<name>/continuity-resolution.json` 的 `capabilities[]`。
-7. KB 不可用 → `degraded` 继续，**禁止**扫本地 `archive/` 抄 UUID。预期：恢复后同锚点入库可能触发 `EXTERNAL_REF_CONFLICT`。
-8. **不得**在本阶段生成 STMT/AC/场景或裁决场景身份。
+5. 若申报了 feature-id：额外 `objectType=feature` resolve 一次，展示「该功能下已有能力 n 个（存活 m / 失效 k）」辅助勾选 CAP 范围；不改变 Continuity 判定优先级。
+6. 按 KB 结果确认 Continuity：`iteration` / `similar-reference` / `new`；勾选本次涉及的 CAP。
+7. 写入 proposal frontmatter：`requirement-refs`（含 `feature-id`）/ `numbering-waiver` + `continuity`。**禁止**写本地 archive 文件夹名作为 `base-archive`。
+8. CAP 级「同 key + 同锚点、不同 entity_id」当场问 A/B/C；决议写入 `continuity-resolution.json` 的 `capabilities[]`。
+9. KB 不可用 → `degraded` 继续，**禁止**扫本地 `archive/` 抄 UUID。
+10. **不得**在本阶段生成 STMT/AC/场景或裁决场景身份；**不得**铸/改 REQ/FEAT 号。
 
 ### 7. 【交互引导】文档拆分模式选择
 

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

@@ -132,10 +132,16 @@ node skywalk-sdd/context-client.cjs \
 - **禁止**从本地 `archive/` 抄 UUID 当跨迭代继承源；跨迭代只认 KB current。
 - 若返回 `available=false` / `degraded=true`，记录降级并继续，不得扫本地 archive 兜底。
 - `INHERIT`：unchanged 写继承引用；modified 复用 entity-id + predecessor。`REFERENCE`：只参考，新开身份。
-- reuseBundle / 实体上的 `externalRefs` 写入场景 `external-ref`（`requirement-mgmt:scenario:REQ-…:SCN-…`）。
-- 场景级「同 SCN key + 同锚点、不同 entity_id」在写完该 CAP identity 后、确认文档前**当场问** A/B/C；未决不得进入下一 CAP / design。决议追加到 `continuity-resolution.json` 的 `scenarios[]`。
+- reuseBundle / 实体上的 `externalRefs` 写入场景 `external-ref`（完整键 `REQ-…:SCN-<slug>-<NNN>`）。
+- **SCN 铸号（本仓唯一铸号点）**：
+  1. 继承优先：`reuseBundle.externalRefs` 已有场景键的 unchanged/modified 场景一律沿用原 SCN 号，禁止另铸。
+  2. 新场景：`SCN-<slug>-<NNN>`；slug=kebab-case 小写 ≤40；NNN=该 REQ 命名空间内 max+1（已用集合=KB 回传 ∪ 本 Change 已写键，含 removed 墓碑）。
+  3. removed 号是墓碑：永不复用、永不重排；序号达 999 → 硬错误，回需求系统拆分需求，不扩位。
+  4. 写完立即用 `cli.cjs external-key --validate … --type scenario` 校验；REQ 前缀必须 ∈ proposal `requirement-refs`。
+- 场景级「同 SCN key + 同锚点、不同 entity_id」当场问 A/B/C；未决不得进入下一 CAP / design。决议追加到 `continuity-resolution.json` 的 `scenarios[]`；决议中的 `externalKey` 必须是归一化形态。
 - 优先消费 `reuseBundles[].statements`；`designElements` 只作理解上下文，不能写成 Spec 的 How。
 - 所有知识库内容均为 advisory；与用户确认 / proposal 冲突时以当前确认与 proposal 为准。
+- **禁止**铸/改 REQ/FEAT；**禁止**自动重排/回收 SCN。
 
 **【可选】业务知识库检索**：
 术语含义不清且可能影响 spec 准确性时，可调用 **opsx-knowledge** skill。

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

@@ -189,7 +189,14 @@ Simple 模式或单文件能力域下，**不要拆成多个同文件任务**。
 
 ### 8. 质量红线自检
 
-> 逐项确认，完整 7 项自检清单 + TDD 合规性自检（结构符合模板 / 拓扑图已绘制 / 依赖字段已填写 / 无循环依赖 / 颗粒度 ≤5 分钟 / 100% 覆盖 design / 每任务有验收标准）见 `./checklist.md`「§8 质量红线自检 + §8.1 TDD 合规性自检」。如有任意一项未满足，重新生成对应章节，直至全部通过。
+> 逐项确认，完整 7 项自检清单 + TDD 合规性自检（结构符合模板 / 拓扑图已绘制 / 依赖字段已填写 / 无循环依赖 / 颗粒度 ≤5 分钟 / 100% 覆盖 design / 每任务有验收标准）见 `./checklist.md`「§8 质量红线自检 + §8.1 TDD 合规性自检」。
+>
+> 额外强制项（见 `./checklist.md` §8）：
+> - ⛔ **CON 覆盖**：spec.md 中每个 CON 必须有对应验证任务或显式声明间接覆盖
+> - ⛔ **安全/审计要求覆盖**：spec.md §5.x 中的安全与审计要求必须有对应任务或显式声明推迟
+> - ⛔ **§4.x 验证方式表内部一致性**：§4.x 验证方式表中的测试注解/配置必须与任务实现步骤中的声明一致
+>
+> 如有任意一项未满足，重新生成对应章节，直至全部通过。
 
 ### 9. 确认任务并输出
 

package/templates/skills/kld-sdd/opsx-task/checklist.md

@@ -29,6 +29,9 @@ description: opsx-task 的阶段强制检查点与自检清单。仅在执行 ta
 - [ ] 每个任务颗粒度 ≤ 5 分钟
 - [ ] 100% 覆盖 design.md 定义
 - [ ] 每个任务都有验收标准
+- [ ] ⛔ **约束（CON）覆盖**：spec.md 中每个 CON 必须有对应验证任务，或在任务中显式声明"通过现有 AC 间接覆盖"并说明理由；tasks.md 质量红线声明"100% 覆盖 CON"时必须可追溯
+- [ ] ⛔ **安全/审计要求覆盖**：spec.md §5.x 中的安全与审计要求（日志记录、脱敏、告警等）必须有对应任务，或显式声明推迟到后续迭代并在任务中标注
+- [ ] ⛔ **§4.x 验证方式表内部一致性**：§4.x 验证方式表中的测试注解/配置必须与任务实现步骤中的声明一致，不得出现"§4.1 声明 @WebMvcTest 但实现步骤允许 @SpringBootTest"的矛盾
 
 **如有任意一项未满足，重新生成对应章节，直至全部通过。**
 

package/templates/skills/kld-sdd/opsx-tdd-anti-patterns/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: opsx-tdd-anti-patterns
-description: "测试反模式防护层 — 15 种反模式检测（RED 阶段 3 种 + GREEN 后 12 种），每种带门禁函数和修复方案。当编写或审查测试代码时引用本技能。"
+description: "测试反模式防护层 — 16 种反模式检测（RED 阶段 3 种 + GREEN 后 13 种），每种带门禁函数和修复方案。当编写或审查测试代码时引用本技能。"
 ---
 
 # opsx-tdd-anti-patterns — 反模式防护层
@@ -32,7 +32,7 @@ description: "测试反模式防护层 — 15 种反模式检测（RED 阶段 3
 | 2 | **Mock 预定结论而非准备条件** | `when(bookMapper.countByPublisher(1L)).thenReturn(3)` 后只测 `if (count > 0) throw` — trivial 逻辑 | "我的测试是在验证完整行为链路，还是只验证一个 if 分支？" | Mock 边界依赖（Mapper）是合理的，但测试断言应验证完整行为链路（如 verify 不会执行 delete） |
 | 3 | **Given 不是真实输入** | mock 出"这个输入会导致什么结果"，而非传入真实数据让被测代码自行处理 | "我的 Given 是真实数据还是 mock 出的预定结论？" | 传入真实数据（如 `"invalid"` 字符串、`null`、空对象），让被测代码自行决定结果 |
 
-## §4 GREEN 后反模式（12 种）
+## §4 GREEN 后反模式（13 种）
 
 | # | 反模式 | 问题表现 | 修复方案 |
 |---|--------|---------|---------|
@@ -48,6 +48,7 @@ description: "测试反模式防护层 — 15 种反模式检测（RED 阶段 3
 | 13 | **魔法值** | 测试中使用未解释的字面值（如 `assertEquals(42, result)` 无注释说明 42 的含义） | 使用命名常量或注释解释字面值含义 |
 | 14 | **断言不足** | 只断言了部分结果，遗漏了关键属性（如只 assertNotNull 但不 assertEquals 具体值） | 每个测试至少有一个具体值断言（assertEquals），而非仅 assertNotNull |
 | 15 | **缺少负面测试** | 只测试正常路径，不测试错误条件 | 每个方法至少有一个异常路径测试（见 `opsx-tdd-rules/rules/exception-path-coverage.md`） |
+| 16 | **AC 变体覆盖不足** | AC 场景描述含"或"条件（如"缺少 A 或 B 或为空"），但测试只覆盖部分变体 | AC 中每个"或"条件变体必须有对应测试方法（规则见 `opsx-tdd-rules/rules/multi-validation-split.md` §AC 内"或"条件变体覆盖） |
 
 ## §5 门禁函数
 
@@ -82,3 +83,5 @@ AFTER GREEN（GREEN 完成后、标记通过前）：
 - 测试中只有 `assertNotNull` 无具体值断言
 - 测试中存在未解释的魔法数字/字符串
 - 正常路径有测试但异常路径无测试
+- AC 场景描述含"或"条件但测试只覆盖部分变体
+- 连续 RED/GREEN 的 task_update 时间戳差距过小（批量执行信号，违反 TDD 严格串行）

package/templates/skills/kld-sdd/opsx-tdd-anti-patterns/reference.md

@@ -195,6 +195,35 @@ assertEquals("user-001", result.getUserId());
 
 **修复**：每个方法至少有一个异常路径测试。规则见 `opsx-tdd-rules/rules/exception-path-coverage.md`。
 
+## 反模式 16：AC 变体覆盖不足
+
+**问题**：AC 场景描述含"或"条件（如"缺少 A 或 B 或为空"），但测试只覆盖部分变体，其余变体无测试守护。
+
+**反例**：
+```java
+// AC-004: 请求体缺少 username 或 password 字段，或字段值为空字符串
+// 仅测试 1/6 变体
+@Test
+void login_withMissingParams_returns1001() {
+    mockMvc.perform(post("/login")
+            .content("{\"username\":\"\",\"password\":\"admin123\"}"))
+            .andExpect(jsonPath("$.code").value(1001));
+}
+```
+
+**正例**：
+```java
+// 每个变体都有测试方法（或参数化测试）
+@Test void login_withEmptyUsername_returns1001() { ... }
+@Test void login_withEmptyPassword_returns1001() { ... }
+@Test void login_withMissingUsernameField_returns1001() { ... }
+@Test void login_withMissingPasswordField_returns1001() { ... }
+@Test void login_withBothEmpty_returns1001() { ... }
+@Test void login_withBothMissing_returns1001() { ... }
+```
+
+**修复**：AC 中每个"或"条件变体必须有对应测试方法。规则见 `opsx-tdd-rules/rules/multi-validation-split.md` §AC 内"或"条件变体覆盖。
+
 ## TDD 如何防止这些反模式
 
 1. 先写测试 → 迫使你思考实际在测试什么

package/templates/skills/kld-sdd/opsx-tdd-core/checklist.md

@@ -40,6 +40,9 @@ description: "opsx-tdd-core 自检清单 — TDD 执行合规自检、合规性
 - [ ] 每个 RED 任务包含测试方法名（`{method}_{state}_{outcome}` 格式）
 - [ ] 每个 GREEN 任务包含 YAGNI 围栏声明（"不提前实现 [后续 RED 行为]"）
 - [ ] 每个 REFACTOR 任务列出至少 2 个具体重构点
+- [ ] ⛔ **CON 覆盖**：spec.md 中每个 CON 在 tasks.md 中有对应验证任务或显式声明间接覆盖
+- [ ] ⛔ **安全/审计要求覆盖**：spec.md §5.x 中的安全与审计要求在 tasks.md 中有对应任务或显式声明推迟
+- [ ] ⛔ **AC 变体覆盖**：spec.md 中含"或"条件的 AC 场景，其 RED 任务验收标准列出所有变体的测试方法（引用 `opsx-tdd-rules/rules/multi-validation-split.md`）
 
 ## §C 完成验证清单（8 项）
 
@@ -53,5 +56,6 @@ description: "opsx-tdd-core 自检清单 — TDD 执行合规自检、合规性
 - [ ] 输出纯净（无错误/警告）
 - [ ] 测试使用真实代码（仅在不可避免时使用 mock）
 - [ ] 边界情况和错误已覆盖
+- [ ] ⛔ **AC "或"条件变体全覆盖**：AC 场景描述含"或"条件时，每个变体都有对应测试方法（引用 `opsx-tdd-rules/rules/multi-validation-split.md`）
 
 > Can't check all boxes? You skipped TDD. Start over.

package/templates/skills/kld-sdd/opsx-tdd-rules/SKILL.md

@@ -24,6 +24,6 @@ description: "TDD 规则库 — DAG 生成规则、Controller 策略、任务类
 | `rules/green-yagni-fence.md` | GREEN 任务 YAGNI 围栏自动注入规则 | HIGH | opsx-task |
 | `rules/green-scope-declaration.md` | GREEN 任务 Scope 声明步骤（断言清单→流程标记→仅实现属于的步骤） | HIGH | opsx-apply |
 | `rules/des-step-annotation.md` | DES 元素步骤级标注规则（TDD 模式下标注 [GREEN-N] 归属） | MEDIUM | opsx-design |
-| `rules/multi-validation-split.md` | 多校验条件拆分规则（每个校验条件须有独立 AC 场景） | MEDIUM | opsx-spec |
+| `rules/multi-validation-split.md` | 多校验条件拆分规则（每个校验条件须有独立 AC 场景；AC 内"或"条件变体须全覆盖） | MEDIUM | opsx-spec, opsx-task, opsx-check |
 | `rules/exception-path-coverage.md` | 异常路径测试覆盖门禁（每个 orElseThrow/边界检查须有对应 RED 测试） | HIGH | opsx-task, opsx-apply, opsx-check |
 | `rules/refactor-checklist.md` | REFACTOR 阶段检查点（public API 不变、行为保持、重构质量评估） | HIGH | opsx-apply, opsx-tdd-core |

package/templates/skills/kld-sdd/opsx-tdd-rules/rules/multi-validation-split.md

@@ -1,7 +1,7 @@
 # 多校验拆分规则
 
 > 影响等级：MEDIUM
-> 引用方：opsx-spec（spec.md 生成）、opsx-spec/checklist.md（自检）
+> 引用方：opsx-spec（spec.md 生成）、opsx-spec/checklist.md（自检）、opsx-task（RED 任务拆解）、opsx-check（一致性检查）
 
 ## 问题
 
@@ -34,3 +34,37 @@ AC-03: 可借数量不足（available_count = 0）
 ```
 
 > 目的：每个校验条件有独立场景 → 独立 RED 测试 → 独立 GREEN 实现，避免 AI 在一个 GREEN 中实现所有校验。
+
+## AC 内"或"条件变体覆盖
+
+> 引用方：opsx-spec（spec.md 生成）、opsx-task（RED 任务拆解）、opsx-check（一致性检查）
+
+### 问题
+
+单个 AC 场景描述中包含"或"条件时（如"缺少 username **或** password 字段，或字段值为空字符串"），AI 在拆解 RED 任务时倾向于只取一个变体编写测试，导致其余变体无测试守护。
+
+### 规则
+
+当单个 AC 场景描述包含"或"条件时，必须检查：
+
+1. 每个"或"条件变体是否有对应的测试方法
+2. 若多个变体共享一个 RED 任务，RED 验收标准中必须列出所有变体的测试方法名
+3. 变体可合并到一个 RED 任务的多个 `@Test` 方法中，但不得遗漏任何变体
+
+### 反例（禁止）
+
+```
+AC-004: 请求体缺少 username 或 password 字段，或字段值为空字符串
+RED-4: login_withMissingParams_returns1001
+  → 仅测试 username="" 一种变体，password="" / 缺少字段 / 双空 / 双缺共 5 种变体未覆盖
+```
+
+### 正例（要求）
+
+```
+AC-004: 请求体缺少 username 或 password 字段，或字段值为空字符串
+RED-4: login_withMissingParams_returns1001（含 6 个 @Test 方法或参数化测试）
+  → username="" / password="" / 缺少 username / 缺少 password / 双空 / 双缺 均有测试
+```
+
+> 目的：spec 中"或"条件描述的每个变体都有测试守护，防止参数校验逻辑回归。