kld-sdd 2.6.11 → 2.6.13

package/templates/hooks/codebuddy/hooks/sdd-apply-test-gate.cjs

@@ -74,6 +74,26 @@ function isRealTestDetails(testResults) {
   return false;
 }
 
+function isPassingTestDetails(testResults) {
+  if (!isRealTestDetails(testResults)) return false;
+  const failed = Number(testResults.failed);
+  const exitCode = Number(testResults.exit_code);
+  return (!Number.isFinite(failed) || failed === 0)
+    && (!Number.isFinite(exitCode) || exitCode === 0);
+}
+
+function isStrictTestEvidence(event, changeName) {
+  const testResults = event?.details?.test_results;
+  if (event?.type !== 'test_result' || event.change !== changeName) return false;
+  if (!event.run_id || !event.source || testResults?.evidence_tier !== 'strict') return false;
+  if (!['green', 'refactor', 'regression'].includes(testResults.tdd_phase)) return false;
+  if (!Number.isInteger(testResults.exit_code) || testResults.counts_known !== true) return false;
+  return event.result === 'success'
+    && testResults.exit_code === 0
+    && Number(testResults.failed) === 0
+    && isPassingTestDetails(testResults);
+}
+
 function loadChangeEvents(projectRoot, changeName) {
   const safe = safeChangeName(changeName);
   const dir = path.join(projectRoot, 'skywalk-sdd', 'events', safe);
@@ -100,33 +120,36 @@ function loadChangeEvents(projectRoot, changeName) {
 function hasRealTestExecution(projectRoot, changeName, capability, sinceTimestamp) {
   const since = sinceTimestamp ? new Date(sinceTimestamp).getTime() : 0;
   const events = loadChangeEvents(projectRoot, changeName);
+  let legacyEvidence = null;
 
   for (const event of events) {
     const ts = new Date(event.timestamp || 0).getTime();
     if (since && ts < since) continue;
 
-    if (event.type === 'stage_end' && event.command === 'test' &&
-        (event.result === 'success' || event.result === 'failure')) {
-      return { kind: 'opsx-test', event };
+    if (event.type === 'stage_end' && event.command === 'test' && event.result === 'success') {
+      legacyEvidence ||= { kind: 'legacy-opsx-test', event };
     }
 
     if (event.type === 'test_result') {
       const tr = event.details && event.details.test_results;
-      if (isRealTestDetails(tr)) {
-        return { kind: 'test_result', event };
+      if (isStrictTestEvidence(event, changeName)) {
+        return { kind: 'strict-test-result', event };
+      }
+      if (event.result === 'success' && isPassingTestDetails(tr)) {
+        legacyEvidence ||= { kind: 'legacy-test-result', event };
       }
     }
 
     if (event.type === 'task_update' && (event.command === 'apply' || !event.command)) {
       const tr = event.details && event.details.test_results;
-      if (isRealTestDetails(tr)) {
+      if (event.result !== 'failure' && isPassingTestDetails(tr)) {
         if (!capability || !event.capability || event.capability === capability) {
-          return { kind: 'task_update', event };
+          legacyEvidence ||= { kind: 'legacy-task-update', event };
         }
       }
     }
   }
-  return null;
+  return legacyEvidence;
 }
 
 function isApplyCompletionBash(command) {
@@ -210,9 +233,10 @@ function shouldGate(projectRoot, applyEvent) {
     applyEvent.capability,
     applyEvent.timestamp
   );
-  if (evidence) {
+  if (evidence?.kind === 'strict-test-result') {
     return null;
   }
+  if (evidence) return { strategy, changeName: applyEvent.change, capability: applyEvent.capability, legacyEvidence: evidence };
   return { strategy, changeName: applyEvent.change, capability: applyEvent.capability };
 }
 
@@ -374,6 +398,11 @@ if (require.main === module) {
   if (!gate) {
     process.exit(0);
   }
+  if (gate.legacyEvidence) {
+    recordWarning(projectRoot, { ...activeApply, test_strategy: gate.strategy }, 'legacy_test_evidence',
+      '仅检测到旧版测试证据；本次兼容放行，请补录包含 run-id、exit code、TDD phase 和严格身份字段的 test_result');
+    process.exit(0);
+  }
 
   const reason = buildReason(gate.strategy, gate.changeName, gate.capability);
   recordWarning(projectRoot, { ...activeApply, test_strategy: gate.strategy }, 'apply_test_missing', 'Apply test gate blocked: no unit test evidence');
@@ -391,5 +420,6 @@ module.exports = {
   detectMissingTddRed,
   hasExistingWarning,
   isRealTestDetails,
+  isStrictTestEvidence,
   requiresUnitTests,
 };

package/templates/hooks/codebuddy/hooks/sdd-post-tool.cjs

@@ -3,8 +3,8 @@
 
 const fs = require('fs');
 const path = require('path');
+const crypto = require('crypto');
 const { execFileSync } = require('child_process');
-const core = require('./hook-gate-core.cjs');
 
 function latestActiveStage(projectRoot) {
   const stateDir = path.join(projectRoot, 'skywalk-sdd', 'state');
@@ -26,19 +26,54 @@ function latestActiveStage(projectRoot) {
 function inferResult(input) {
   const response = input.tool_response || input.toolResponse || {};
   if (typeof response.exit_code === 'number') {
-    return { result: response.exit_code === 0 ? 'success' : 'failure', exit_code_known: true };
+    return { result: response.exit_code === 0 ? 'success' : 'failure', exit_code_known: true, exit_code: response.exit_code };
   }
   if (typeof response.exitCode === 'number') {
-    return { result: response.exitCode === 0 ? 'success' : 'failure', exit_code_known: true };
+    return { result: response.exitCode === 0 ? 'success' : 'failure', exit_code_known: true, exit_code: response.exitCode };
   }
   if (typeof response.success === 'boolean') {
-    return { result: response.success ? 'success' : 'failure', exit_code_known: true };
+    return { result: response.success ? 'success' : 'failure', exit_code_known: true, exit_code: response.success ? 0 : 1 };
   }
   const out = String(response.stdout || response.stderr || '');
   if (/BUILD FAILED|error TS\d+|ERR_/i.test(out)) {
-    return { result: 'failure', exit_code_known: false };
+    return { result: 'failure', exit_code_known: false, exit_code: null };
   }
-  return { result: 'partial', exit_code_known: false };
+  return { result: 'partial', exit_code_known: false, exit_code: null };
+}
+
+function parseTestCounts(output) {
+  const text = String(output || '');
+  const tapPass = text.match(/#\s*pass(?:ed)?\s+(\d+)/i);
+  const tapFail = text.match(/#\s*fail(?:ed)?\s+(\d+)/i);
+  const tapSkip = text.match(/#\s*skip(?:ped)?\s+(\d+)/i);
+  if (tapPass || tapFail) {
+    return {
+      counts_known: true,
+      passed: Number(tapPass?.[1] || 0),
+      failed: Number(tapFail?.[1] || 0),
+      skipped: Number(tapSkip?.[1] || 0),
+    };
+  }
+  const summary = text.match(/Tests?\s+.*?(\d+)\s+passed(?:.*?(\d+)\s+failed)?(?:.*?(\d+)\s+skipped)?/i);
+  if (summary) {
+    return {
+      counts_known: true,
+      passed: Number(summary[1] || 0),
+      failed: Number(summary[2] || 0),
+      skipped: Number(summary[3] || 0),
+    };
+  }
+  return { counts_known: false };
+}
+
+function stableRunId(input, activeStage, command) {
+  const explicit = input.tool_use_id || input.toolUseId || input.tool_call_id || input.toolCallId;
+  if (explicit) return String(explicit);
+  const response = input.tool_response || input.toolResponse || {};
+  return `hook-${crypto.createHash('sha256')
+    .update(JSON.stringify([activeStage.event_id || '', activeStage.session_id || '', command, response]))
+    .digest('hex')
+    .slice(0, 20)}`;
 }
 
 function inferRecord(command) {
@@ -69,6 +104,34 @@ function recordTelemetry(projectRoot, activeStage, record, result, exitCodeKnown
   const toolInput = (input && (input.tool_input || input.toolInput)) || {};
   const toolResponse = (input && (input.tool_response || input.toolResponse)) || {};
   const details = { [record.detailsKey]: { ...record.details } };
+  let strictTestEvent = false;
+  let runId = null;
+  if (record.type === 'test_result') {
+    const output = String(toolResponse.stdout || '') + '\n' + String(toolResponse.stderr || '');
+    const counts = parseTestCounts(output);
+    const exitCode = typeof toolResponse.exit_code === 'number'
+      ? toolResponse.exit_code
+      : (typeof toolResponse.exitCode === 'number'
+        ? toolResponse.exitCode
+        : (typeof toolResponse.success === 'boolean' ? (toolResponse.success ? 0 : 1) : null));
+    const tddPhase = toolInput.tdd_phase || input.tdd_phase || 'regression';
+    details.test_results = {
+      command: toolInput.command || record.details.command,
+      tdd_phase: tddPhase,
+      exit_code: exitCode,
+      counts_known: counts.counts_known,
+      ...(counts.counts_known ? {
+        passed: counts.passed,
+        failed: counts.failed,
+        skipped: counts.skipped,
+      } : {}),
+      duration_ms: Number.isFinite(toolResponse.duration_ms) ? toolResponse.duration_ms : 0,
+      failure_type: result === 'failure' ? (exitCode == null ? 'infrastructure' : 'assertion') : 'none',
+      expected_failure: tddPhase === 'red' && result === 'failure' && exitCode != null,
+    };
+    strictTestEvent = exitCode != null && Boolean(activeStage.task_id);
+    runId = stableRunId(input || {}, activeStage, details.test_results.command);
+  }
   if (record.type === 'build_result') {
     details.build_results.success = result === 'success';
     details.build_results.error_count = result === 'success' ? 0 : null;
@@ -82,7 +145,7 @@ function recordTelemetry(projectRoot, activeStage, record, result, exitCodeKnown
     logCli,
     'record',
     `--type=${record.type}`,
-    `--command=${toolInput.command || activeStage.command || activeStage.stage || 'unknown'}`,
+    `--command=${activeStage.command || activeStage.stage || 'unknown'}`,
     `--project=${projectRoot}`,
     `--change=${activeStage.change || 'general'}`,
     `--agent=${activeStage.agent_type || 'codebuddy'}`,
@@ -91,14 +154,22 @@ function recordTelemetry(projectRoot, activeStage, record, result, exitCodeKnown
     `--summary=CodeBuddy hook captured ${record.type}`,
     `--details-json=${JSON.stringify(details)}`,
   ];
+  if (strictTestEvent) {
+    args.push(
+      '--strict',
+      `--run-id=${runId}`,
+      `--session-id=${activeStage.session_id || `stage-${activeStage.event_id}`}`,
+    );
+  }
   if (activeStage.capability) args.push(`--capability=${activeStage.capability}`);
   if (activeStage.task_id) args.push(`--task-id=${activeStage.task_id}`);
-  if (activeStage.session_id) args.push(`--session-id=${activeStage.session_id}`);
+  if (!strictTestEvent && activeStage.session_id) args.push(`--session-id=${activeStage.session_id}`);
   const run = runner || ((a) => execFileSync('node', a, { cwd: projectRoot, stdio: 'ignore' }));
   run(args);
 }
 
 if (require.main === module) {
+  const core = require('./hook-gate-core.cjs');
   const parsed = core.parseHookInput(core.readStdin(), { strict: false });
   const input = core.normalizeHookInput(parsed.input || {});
   const toolInput = input.tool_input || {};
@@ -120,4 +191,11 @@ if (require.main === module) {
   }
 }
 
-module.exports = { inferResult, inferRecord, recordTelemetry, latestActiveStage };
+module.exports = {
+  inferResult,
+  inferRecord,
+  parseTestCounts,
+  stableRunId,
+  recordTelemetry,
+  latestActiveStage,
+};

package/templates/hooks/codebuddy/hooks/sdd-prompt.cjs

@@ -13,8 +13,27 @@ if (!/\/opsx[:|-]/.test(prompt)) {
   process.exit(0);
 }
 
+function resolveSkywalkDir(dir) {
+  const direct = path.join(dir, 'skywalk-sdd');
+  if (fs.existsSync(path.join(direct, 'log.cjs')) || fs.existsSync(path.join(direct, 'log.js'))) {
+    return direct;
+  }
+  const hintFile = path.join(dir, '.sdd-spec-root');
+  if (fs.existsSync(hintFile)) {
+    const rel = String(fs.readFileSync(hintFile, 'utf8') || '').trim().split(/\r?\n/)[0].trim();
+    if (rel) {
+      const nested = path.join(dir, rel, 'skywalk-sdd');
+      if (fs.existsSync(path.join(nested, 'log.cjs')) || fs.existsSync(path.join(nested, 'log.js'))) {
+        return nested;
+      }
+    }
+  }
+  return null;
+}
+
 function readActiveStages(projectRoot) {
-  const stateDir = path.join(projectRoot, 'skywalk-sdd', 'state');
+  const skywalk = resolveSkywalkDir(projectRoot);
+  const stateDir = skywalk ? path.join(skywalk, 'state') : path.join(projectRoot, 'skywalk-sdd', 'state');
   if (!fs.existsSync(stateDir)) return [];
   return fs.readdirSync(stateDir)
     .filter((file) => file.endsWith('.json'))
@@ -35,8 +54,10 @@ const activeStages = readActiveStages(projectRoot)
 
 const lines = [
   'SDD Telemetry reminder:',
-  '- Run skywalk-sdd/log.cjs start before the OPSX stage work begins.',
-  '- Run skywalk-sdd/log.cjs end before stopping the stage.',
+  '- Resolve the exact change key first; every standard OPSX start/end command must include --change=<change-key>.',
+  '- Run node "$(cat .sdd-spec-root)/skywalk-sdd/log.cjs" start before the OPSX stage work begins.',
+  '- Run node "$(cat .sdd-spec-root)/skywalk-sdd/log.cjs" end with the same change, stage, session and event identity before stopping.',
+  '- change=general is reserved for explicitly allowed explore events and must later use scope_link for historical attribution.',
   '- Hooks are only an enhancement; OPSX skill instructions remain authoritative.',
 ];
 

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

@@ -27,18 +27,19 @@ allowed-tools:
 > - ⛔ **隔离红线**：绝对禁止加载同级其他 Capability 的文档
 
 > **🖥️ 跨平台执行规则**
-> - **写代码**：cwd 保持在 Git 根（含 `src/`）；**文档 / telemetry**：`--project` 指向 SDD 包裹包（`node skywalk-sdd/ontology/cli.cjs spec-root` 可查看）。
-> - `openspec` 命令：优先 `node skywalk-sdd/openspec-shim.cjs list`（自动 cd 到包裹包）。
+> - **写代码**：cwd 保持在 Git 根（含 `src/`）；**文档 / telemetry**：`--project` 指向 SDD 包裹包（`node "$(cat .sdd-spec-root)/skywalk-sdd/ontology/cli.cjs" spec-root` 可查看）。
+> - `openspec` 命令：优先 `node "$(cat .sdd-spec-root)/skywalk-sdd/openspec-shim.cjs" list`（自动 cd 到包裹包）。
 > - Telemetry 命令默认使用 `--project=.`，兼容 Windows、macOS、Linux。
 > - ${SHELL_GUIDANCE}
 > - 不要省略 `--source=opsx-command` 与 `--session-id=<会话ID>`。
 > **📊 Telemetry（必做，不得跳过）**
 > - 阶段开始 / 阶段结束 / `task_update` / `ai_adoption_review` / `worktree_finish` 的**完整命令模板**见 `./reference.md`「📊 Telemetry 命令模板」。
 > - 不得跳过任何 telemetry 记录；`task_update` 的 `--task-id=<TASK-ID>` 必须替换为实际任务 ID，否则 E4 指标无法计算；TDD 测试骨架任务须在 `--details-json` 带 `"task_kind":"test-skeleton"`（P3，详见 `./reference.md`）。
-> - 较大的 `--details-json` 负载可先写入文件，再通过 `--details-file=skywalk-sdd/state/<变更名称>-<type>.json` 传递（例如 `task_update` 对应 `<变更名称>-task-update.json`）。
+> - 较大的 `--details-json` 负载可先写入文件，再通过 `--details-file="$(cat .sdd-spec-root)/skywalk-sdd/state/<变更名称>-<type>.json"` 传递（例如 `task_update` 对应 `<变更名称>-task-update.json`）。
 > - `task_update` 记录成功后会自动调用 `check-task` 更新 `tasks.md` 中的 checkbox；录入成功后，agent 可以通过 `check-task` 命令验证该 checkbox 已更新。
 > - **⚠️ P1-2 ai_adoption_review 必填 ai_diff**：记录 AI 产出快照时，`--details-json` 必须含 `ai_diff.files_changed`（即使=0）与 `ai_diff.files`（产出文件路径数组，非空），**不得只发 `assertions`**。`vcs_mode=readonly` 时 `ai_diff.added_lines` 不得为 null——用只读 `git diff --numstat HEAD` 取值（apply Git 只读策略允许）；`vcs_mode=no-git` 时可填 null。工具侧已加记录时硬校验：`files` 空数组或 `readonly` 下 `added_lines=null` 将 **拒绝记录**（与 conformance_review 校验对称）。缺失 `ai_diff` 会导致 report 变更文件数为 null（工具侧已加 `assertions[].files` 兜底，但 `ai_diff` 是主数据源）。完整模板见 `./reference.md`「§5.1」。
-> - **⚠️ P1-3 process_note 必记**：阶段内发生 修复/澄清/决策/API 故障/换模型 时，**必须**记 `process_note` 事件（`kind` 见 `./reference.md`「必记节点清单」）。全程 0 条 process_note 视为过程记录缺失，report 过程记录区显示空。
+> - **严格证据链**：一次真实测试执行只写一条严格 `test_result`；任务完成事件只通过 `test_event_id` 引用成功的 green/refactor/regression 测试，并明确 `tdd_required=true/false`，不复制测试计数。测试不适用时必须写明原因。完整 schema 见 `./reference.md`。
+> - **process_note 必记**：用户决策、范围变化、API/模型/测试异常及恢复动作必须写严格 `process_note`；范围、模式、测试策略选择统一用 `kind=user_decision` 并标注 `decision_type`。
 
 > **🔒 Git 策略（只读增强，不改变开发流）**
 > - Git 只作为可选度量数据源，不是 apply 前置条件。
@@ -205,29 +206,29 @@ g. **继续下一个层级** — 重新检查 DAG，找出依赖已满足的下
 3. **GREEN**：读取 RED 失败原因 → 执行 GREEN Scope 声明 → 逐条确认 YAGNI 围栏 → 写最少代码让测试通过 → 禁止捆绑未测试代码
 4. **GREEN Scope 门禁**：Verify GREEN 之后，检查生产代码无越界逻辑分支（属于后续 RED 的行为 → 删除）
 5. **REFACTOR**：在测试全绿状态下重构 → 运行全部测试确认仍绿
-6. **可选：TDD 审查子代理**：GREEN 任务完成后，可派发独立审查子代理执行 `opsx-tdd-review/SKILL.md` §7（子代理审查提示模板），检测"测试通过但没测到关键点"。implementer 自审查 ≠ 独立审查。
+6. **可选：TDD 审查子代理**：GREEN 任务完成后，可派发独立审查子代理执行 `tdd-review/SKILL.md` §7（子代理审查提示模板），检测"测试通过但没测到关键点"。implementer 自审查 ≠ 独立审查。
 7. 再进入下一个任务
 
-> 完整执行步骤见 opsx-tdd-core/reference.md §1-§3
-> 合理化预防表见 opsx-tdd-core/SKILL.md §7
-> REFACTOR 检查点见 opsx-tdd-rules/rules/refactor-checklist.md
-> 异常路径覆盖门禁见 opsx-tdd-rules/rules/exception-path-coverage.md
+> 完整执行步骤见 tdd-core/reference.md §1-§3
+> 合理化预防表见 tdd-core/SKILL.md §7
+> REFACTOR 检查点见 tdd-rules/rules/refactor-checklist.md
+> 异常路径覆盖门禁见 tdd-rules/rules/exception-path-coverage.md
 > TDD 节奏校验（执行后校验）见 `./checklist.md` §5e.1
 
 **【S2.1 RED 测试质量标准】**（test-strategy=tdd 时强制）：
 
 ⛔ RED 测试质量门禁见 `./checklist.md`「§5e.2 RED 测试质量门禁」，核心包括：
-- Mock 边界（引用 opsx-tdd-quality/SKILL.md §2）
-- 测试命名与结构（引用 opsx-tdd-quality/SKILL.md §3-§4）
-- 断言深度（引用 opsx-tdd-anti-patterns/SKILL.md §4 反模式 14）
-- RED 阶段反模式检查（引用 opsx-tdd-anti-patterns/SKILL.md §3）
+- Mock 边界（引用 tdd-quality/SKILL.md §2）
+- 测试命名与结构（引用 tdd-quality/SKILL.md §3-§4）
+- 断言深度（引用 tdd-anti-patterns/SKILL.md §4 反模式 14）
+- RED 阶段反模式检查（引用 tdd-anti-patterns/SKILL.md §3）
 
 ⛔ BEFORE 编写 RED 测试，必须读取：
-- opsx-tdd-anti-patterns/SKILL.md §3（RED 阶段 3 种反模式 + 门禁函数）
+- tdd-anti-patterns/SKILL.md §3（RED 阶段 3 种反模式 + 门禁函数）
 读取后在报告中确认："已读取 RED 阶段反模式检查表"。
 
-> 完整 Mock 边界矩阵见 opsx-tdd-quality/SKILL.md §2
-> 完整 15 种反模式见 opsx-tdd-anti-patterns/SKILL.md §3-§4
+> 完整 Mock 边界矩阵见 tdd-quality/SKILL.md §2
+> 完整 15 种反模式见 tdd-anti-patterns/SKILL.md §3-§4
 
 ### 5f. 【S3 apply 结束前 checkbox 全量自检】
 

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

@@ -14,7 +14,7 @@ description: opsx-apply 的阶段强制检查点与自检清单。仅在执行 a
 ### §1.2 Check 门禁（apply 前必做）
 
 - [ ] 读取 telemetry 事件数据，检查当前 change 是否已有完成的 check 阶段
-  - `node skywalk-sdd/log.cjs doctor --project=. --change=<change-name>` 或搜 `skywalk-sdd/data/events/<change-name>/` 的 `stage_end` + `command=check` + `result=success`
+  - `node "$(cat .sdd-spec-root)/skywalk-sdd/log.cjs" doctor --project=. --change=<change-name>` 或搜 `skywalk-sdd/data/events/<change-name>/` 的 `stage_end` + `command=check` + `result=success`
 - [ ] check 已完成 ✅ → 继续 apply 流程
 - [ ] check 未完成 ❌ → **强制拒绝** apply，引导用户先执行 `/opsx-check <change-name>`（不得跳过）
 - [ ] telemetry 数据缺失（新项目无历史） → 提示首次执行先运行 `/opsx-check`，询问是否现在执行
@@ -34,7 +34,7 @@ description: opsx-apply 的阶段强制检查点与自检清单。仅在执行 a
 
 ### §5e 测试执行门禁（按 `proposal.md` 的 `test-strategy`）
 
-> 测试执行门禁策略见 opsx-tdd-rules/rules/test-execution-gate.md
+> 测试执行门禁策略见 tdd-rules/rules/test-execution-gate.md
 
 - [ ] `tdd` → ⛔ 强制执行（RED 确认失败、GREEN 确认通过、REFACTOR 全部测试仍绿）
 - [ ] `impl-first` → ⚠️ 警告模式
@@ -42,10 +42,10 @@ description: opsx-apply 的阶段强制检查点与自检清单。仅在执行 a
 
 ### §5e.1 TDD 执行合规自检（仅 test-strategy=tdd 时）
 
-⛔ 每完成一个 RED/GREEN/REFACTOR 任务后，必须执行 `opsx-tdd-core/checklist.md` §A（11 项）逐项勾选。
+⛔ 每完成一个 RED/GREEN/REFACTOR 任务后，必须执行 `tdd-core/checklist.md` §A（11 项）逐项勾选。
 
-> 不在此内联复制，以 opsx-tdd-core/checklist.md §A 为唯一真相源。
-> 额外补充：REFACTOR 任务还需执行 `opsx-tdd-rules/rules/refactor-checklist.md`（7 项重构检查点）。
+> 不在此内联复制，以 tdd-core/checklist.md §A 为唯一真相源。
+> 额外补充：REFACTOR 任务还需执行 `tdd-rules/rules/refactor-checklist.md`（7 项重构检查点）。
 
 ⛔ **TDD 节奏校验**（RED→GREEN 严格串行的执行后校验）：
 - [ ] 连续的 RED-N `task_update` 与 GREEN-N `task_update` 之间有可验证的执行间隔（建议 >60 秒），若时间戳差距过小视为批量执行信号
@@ -54,50 +54,50 @@ description: opsx-apply 的阶段强制检查点与自检清单。仅在执行 a
 
 ### §5e.2 RED 测试质量门禁（仅 test-strategy=tdd 时，RED 任务完成后强制检查）
 
-⛔ 核心原则（引用 opsx-tdd-quality/SKILL.md §2）：Mock 边界，不 Mock 行为
+⛔ 核心原则（引用 tdd-quality/SKILL.md §2）：Mock 边界，不 Mock 行为
 - [ ] 未 mock 被测行为本身
 - [ ] Mock 仅用于系统边界依赖（Mapper/HTTP）
 - [ ] RED 测试 Given 是真实输入
 
-⛔ 测试命名与结构（引用 opsx-tdd-quality/SKILL.md §3-§4）：
+⛔ 测试命名与结构（引用 tdd-quality/SKILL.md §3-§4）：
 - [ ] 测试方法名符合 `{method}_{state}_{outcome}` 格式
 - [ ] 测试包含 `// Given` / `// When` / `// Then` 注释结构
 - [ ] 一测一场景（测试方法名不含 "and"）
 
-⛔ 断言深度（引用 opsx-tdd-anti-patterns/SKILL.md §4 反模式 14）：
+⛔ 断言深度（引用 tdd-anti-patterns/SKILL.md §4 反模式 14）：
 - [ ] 每个测试至少有一个具体值断言（assertEquals），而非仅 assertNotNull
 - [ ] 异常测试使用 `assertThrows(BusinessException.class, ...)` 并验证错误码（而非 RuntimeException.class）
 
 ⛔ BEFORE 标记 RED 任务完成，必须读取：
-- opsx-tdd-anti-patterns/SKILL.md §3（RED 阶段反模式检查）
+- tdd-anti-patterns/SKILL.md §3（RED 阶段反模式检查）
 读取后确认："已检查 RED 阶段反模式"。
 
-> 完整质量门禁见 opsx-tdd-quality/SKILL.md §2-§6
-> 完整 15 种反模式见 opsx-tdd-anti-patterns/SKILL.md §3-§4
+> 完整质量门禁见 tdd-quality/SKILL.md §2-§6
+> 完整 15 种反模式见 tdd-anti-patterns/SKILL.md §3-§4
 
 ### 任务状态实时更新
 
-- [ ] tasks.md：`- [ ]` → `- [x]`（拓扑图和任务详情中的复选框）
-- [ ] 同时：`- **状态**: [ ] 未完成` → `- **状态**: [x] 已完成`
-- [ ] 两种格式同步更新，不可遗漏
+- [ ] 每个主任务只保留一条规范状态行：`- **状态**: [ ] 未完成` → `- **状态**: [x] 已完成`
+- [ ] 自动同步仅更新任务块内的 `- **状态**:` 行，不改标题复选框、场景列表或验收清单
+- [ ] “验收证据”与主任务进度分开统计；必须由真实测试、人工验收或评审证据确认，不自动勾选
 - [ ] 显示进度：`✅ [TASK-ID] 已完成 [N/M]`
-- [ ] 记录任务级 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 并报告
+- [ ] 记录严格任务事件：`task_update` 必须含 `--task-id`、`--run-id`，完成时引用成功的 green/refactor/regression `test_event_id` 并明确 `tdd_required=true/false`；测试不适用时写明 `verification_not_applicable_reason`
+- [ ] ⛔ **task_update 后必须验证状态已更新**：执行 `node "$(cat .sdd-spec-root)/skywalk-sdd/index.cjs" check-task --project=. --change=<变更名称> --task-id=<TASK-ID>`，确认对应规范状态行已变为 `[x]`
 
 ### §5f.1 apply 结束前 checkbox 全量同步校验
 
 > ⛔ 在 `stage_end` telemetry 记录前必须执行此校验，防止任务状态滞后到 archive 阶段。
 
-- [ ] 对比 telemetry `task_update` 记录的已完成任务数与 tasks.md 中 `[x]` 数量，不一致则补齐
-- [ ] tasks.md 中所有 `- [ ]` / `- [x]` 与 `**状态**: [ ]` / `[x]` 两种格式已同步
-- [ ] 手动验证清单（如有）已勾选
+- [ ] 对比 telemetry `task_update` 已完成任务数与 `primary_tasks.completed`，不一致则修正任务状态或事件
+- [ ] `acceptance_evidence` 单独报告已确认/待确认数量，不将其混入任务完成率
+- [ ] 手动验证清单（如有）仅在真实完成后勾选
 - [ ] 文档更新项（如有）已完成或显式标注推迟
 
 ---
 
 ## §6.0 单元测试真实执行自检（`test-strategy` 非 `none`）
 
-> 单元测试真实执行自检见 opsx-tdd-core/reference.md §9
+> 单元测试真实执行自检见 tdd-core/reference.md §9
 
 - [ ] 真实运行单元测试命令并留 telemetry 证据
 - [ ] `tdd`：无测试证据不得结束 apply / 不得 finish worktree
@@ -112,7 +112,7 @@ description: opsx-apply 的阶段强制检查点与自检清单。仅在执行 a
 - [ ] 主仓库无与 merge 冲突的未跟踪文件（见 §1.5 Step 0.5）
 - [ ] `test-strategy` 为 `tdd`/`impl-first` 时，§6.0 测试证据已存在
 - [ ] 在**主仓库根目录**执行收尾脚本（禁止在 `.worktrees/...` 内执行）
-- [ ] 执行：`node skywalk-sdd/apply-worktree-finish.cjs --change=<变更名称> --capability=<capability-name>`
+- [ ] 执行：`node "$(cat .sdd-spec-root)/skywalk-sdd/apply-worktree-finish.cjs" --change=<变更名称> --capability=<capability-name>`
 - [ ] 默认 merge 目标 = §1.5 `--record-base` 写入的 `integration_base`（**不是**默认 master）
 - [ ] 若 §1.5 判定未建 worktree（串行、强依赖、沙箱回退）→ 跳过本节
 
@@ -126,7 +126,7 @@ description: opsx-apply 的阶段强制检查点与自检清单。仅在执行 a
 - [ ] ⛔ **DAG 依赖拦截**：执行任务前必须检查依赖，前置未完成必须拦截
 - [ ] ⛔ **编译检查门禁**：每完成一个任务后必须运行编译检查，编译失败禁止标记已完成
 - [ ] ⛔ **测试执行门禁**：根据 `test-strategy` 决定（tdd=强制, impl-first=强制补跑, none=跳过）；须真实执行并留 telemetry，`sdd-apply-test-gate` 校验非占位数据
-- [ ] ⛔ **RED 测试质量门禁**：见 §5e.2（引用 opsx-tdd-quality + opsx-tdd-anti-patterns，不在此内联复制）
+- [ ] ⛔ **RED 测试质量门禁**：见 §5e.2（引用 tdd-quality + 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 对应行已变更；未更新则手动修改

package/templates/skills/kld-sdd/opsx-apply/implementer-prompt.md

@@ -14,26 +14,26 @@ NO PRODUCTION CODE WITHOUT A FAILING TEST FIRST.
 2. 编写测试代码：Given-When-Then 结构 + 真实断言
 3. 运行测试，确认失败（失败原因必须是功能未实现）
 4. 如果测试通过：说明测试无效或功能已存在，重新编写
-5. ⛔ 检查异常路径覆盖：每个 orElseThrow/边界检查须有对应测试方法（见 `opsx-tdd-rules/rules/exception-path-coverage.md`）
+5. ⛔ 检查异常路径覆盖：每个 orElseThrow/边界检查须有对应测试方法（见 `tdd-rules/rules/exception-path-coverage.md`）
 
 ⛔ BEFORE 编写测试代码，必须读取对应语言的规则文件：
-- Java：opsx-tdd-quality/rules/java/java-test-template.md + argument-matching.md + domain-service-rules.md
-- TypeScript：opsx-tdd-quality/rules/typescript/ts-test-template.md
-- Python：opsx-tdd-quality/rules/python/py-test-template.md
-- 通用：opsx-tdd-quality/rules/general/naming-conventions.md + given-when-then.md + no-logic-in-tests.md
+- Java：tdd-quality/rules/java/java-test-template.md + argument-matching.md + domain-service-rules.md
+- TypeScript：tdd-quality/rules/typescript/ts-test-template.md
+- Python：tdd-quality/rules/python/py-test-template.md
+- 通用：tdd-quality/rules/general/naming-conventions.md + given-when-then.md + no-logic-in-tests.md
 读取后在报告中列出已读取的规则文件路径。
 
 ### 执行 实现-GREEN 任务
 1. 读取对应 RED 任务的失败原因
-2. 【Scope 声明】按 `opsx-tdd-rules/rules/green-scope-declaration.md` 执行 Scope 声明步骤
+2. 【Scope 声明】按 `tdd-rules/rules/green-scope-declaration.md` 执行 Scope 声明步骤
 3. 编写最少代码——仅实现 Scope 声明中标记为"属于当前 RED"的步骤
 4. 【Scope 自检】检查生产代码中是否有未被任何当前 RED 断言覆盖的逻辑路径？有则删除
 5. 不提前实现没有测试要求的功能（YAGNI）
 6. 禁止捆绑未测试的代码（Controller/Filter/Config）
 
-> 完整执行步骤见 opsx-tdd-core/reference.md §1-§3
-> 完整质量标准见 opsx-tdd-quality/SKILL.md §2
-> Scope 声明规则见 opsx-tdd-rules/rules/green-scope-declaration.md
+> 完整执行步骤见 tdd-core/reference.md §1-§3
+> 完整质量标准见 tdd-quality/SKILL.md §2
+> Scope 声明规则见 tdd-rules/rules/green-scope-declaration.md
 
 ### 执行 重构-REFACTOR 任务
 1. 在所有测试通过的状态下开始
@@ -41,9 +41,9 @@ NO PRODUCTION CODE WITHOUT A FAILING TEST FIRST.
 3. 运行**全部测试**：`mvn test`（或项目对应命令）
 4. 确认所有测试仍通过
 5. 如果任何测试失败：回退重构，重新尝试
-6. ⛔ 执行 `opsx-tdd-rules/rules/refactor-checklist.md`（7 项重构检查点）
+6. ⛔ 执行 `tdd-rules/rules/refactor-checklist.md`（7 项重构检查点）
 
-> 完整 REFACTOR 检查点见 opsx-tdd-rules/rules/refactor-checklist.md
+> 完整 REFACTOR 检查点见 tdd-rules/rules/refactor-checklist.md
 
 ## 派发格式
 
@@ -94,7 +94,7 @@ Agent (general-purpose):
     3. 遵循 overview.md 的全局规范
     4. 保持变更最小化，不超出任务范围
     5. **当任务类型为 测试-RED 时**：编写带真实断言的测试，运行并确认失败，记录失败原因
-    6. **当任务类型为 实现-GREEN 时**：读取对应 RED 的失败原因，按 `opsx-tdd-rules/rules/green-scope-declaration.md` 执行 Scope 声明，仅实现标记为"属于"的步骤，写最少代码让测试通过，不提前实现未要求的功能
+    6. **当任务类型为 实现-GREEN 时**：读取对应 RED 的失败原因，按 `tdd-rules/rules/green-scope-declaration.md` 执行 Scope 声明，仅实现标记为"属于"的步骤，写最少代码让测试通过，不提前实现未要求的功能
     7. **当任务类型为 重构-REFACTOR 时**：在测试全绿状态下优化代码，运行全部测试确认仍绿
     8. 自我审查（见下方）
     9. 报告结果