feat(absorption): enforce executable absorb with probes for R1-R4 and T2

Require SourceExistence, ProbeNecessity, and enforcementLevel before absorb.
Land ProgressReportFastPath, TaskPhaseProjection, ClosedArtifactNoRevive,
FormalRerunLightClassify, and FindingObjectLayer with classifiers and tests.

Author: rockyshi1993

changelogs/unreleased.md

@@ -5,6 +5,9 @@
 
 ## 当前未发布实现候选
 
+- **SourceExistenceVerificationGate（规范吸纳防复发）**：`spec-absorption` 强制在输出「可吸纳」前对 source-root 做同名/近邻存在性验证；台账 `open/pending absorption` 不得单独成 absorb。`AbsorptionCandidateMatrixV1` 增加 `sourceExistence`；planner 阻断 `unverified` 与 `present/equivalent-covered` 的 absorb；并列「可关账清单」。负向：ledger-status-only。验证：`node scripts/plan-absorption-candidates.js --self-test`、`npm run test:residual-absorption-controls`、V81 needles。
+- **ExecutableAbsorption + ProbeNecessity（假吸纳禁止）**：吸纳必须可执行——`enforcementLevel` 不得为 checklist-only/none；每条 absorb 必填 `probeNecessity`（required/conditional/not-required/forbidden、alwaysOnImpact、复杂度与误报）。只写 Skill 正文或「以后再补探针」不得 ready/absorbed。分类器 `classifyExecutableAbsorptionSample`。验证：planner self-test + residual + V81。
+- **可执行吸纳主包 A 实施（R1～R4 + T2）**：`ProgressReportFastPath`（skill-gap/compliance/SC16）；`TaskPhaseProjectionGate`（cp-gate/user-visible-output）；`ClosedArtifactNoReviveGate`（cp-gate）；`FormalRerunLightClassify` + `FindingObjectLayer`（consumer-validation）。探针：`scripts/lib/executable-absorption-gates.js` + `npm run test:executable-absorption-gates`（并入 host-parity / control-plane）。
 - **GlobalOnly 全局 adapter 本地刷新 CLI（R1a）**：新增 `devcodex global-adapters apply [--dry-run] [--json]` 与 `npm run global-adapters:apply*`，从当前包根复用 `applyGlobalHostConfig` 刷新用户级五宿主 adapter（不 pack/不 publish）。nextStep/PC5/audit/V8/doctor/help/website intro 按源码 vs 已发布分流；次选 R1b `npm install -g .`、R2 pack+tarball、R3 `npm update -g`；bare `devcodex update` 仅 workspace。`package.json` files 已纳入 `global-adapters-cli` / guidance 模块，避免 pack 后 require 断裂。**Profile 01/02/04/05/06/07 已同步 R1a~R4**（PI-173）。任务：`bugs/GlobalOnly刷全局副本命令口径漂移修复`。
 - **R1a 复审收口**：`host-parity-scorecard` repairSteps / recommendedEntry / userVisibleSummary 接入 `describeGlobalAdapterRefresh*`（源码 → `global-adapters apply`，已发布 → `npm -g`）；`global-adapters apply` 在主机事务已提交但 Grok 集成失败时返回 `GLOBAL_ADAPTERS_HOSTS_COMMITTED_GROK_FAILED` + `partialState`；npm pack `files` 不再包含 `test-global-adapters-cli.js`。
 - **MCP runtime dep 防断**：将 `global-adapter-refresh-guidance.js` 纳入 `MCP_RUNTIME_DEPS` / `CLAUDE_MCP_RUNTIME_SCRIPT_DEPS`；`host-parity-scorecard` 对 guidance 模块 soft-require，避免精简 runtime 缺文件时 `MODULE_NOT_FOUND`。

scripts/lib/absorption-candidate-planner.js

@@ -32,6 +32,21 @@ const CLASSIFICATIONS = new Set([
   'project-local',
   'already-covered'
 ])
+const EXISTENCE_STATUSES = new Set(['absent', 'partial', 'present', 'equivalent-covered', 'unverified'])
+const LEDGER_DISPOSITIONS = new Set(['absorb-candidate', 'residual-candidate', 'close-ledger', 'defer'])
+const COVERED_EXISTENCE = new Set(['present', 'equivalent-covered'])
+const ENFORCEMENT_LEVELS = new Set(['hard-probe', 'structural-gate', 'conditional-probe', 'checklist-only', 'none'])
+const PROBE_CLASSES = new Set([
+  'machine-sample',
+  'structural-schema',
+  'fixture-replay',
+  'extend-existing',
+  'checklist-only',
+  'probe-forbidden'
+])
+const PROBE_NECESSITIES = new Set(['required', 'conditional', 'not-required', 'forbidden'])
+const ALWAYS_ON_IMPACTS = new Set(['none', 'test-only', 'conditional-path', 'always-on-path'])
+const WEAK_ENFORCEMENT = new Set(['checklist-only', 'none'])
 
 function stableStringify(value) {
   if (Array.isArray(value)) return `[${value.map(stableStringify).join(',')}]`
@@ -70,6 +85,183 @@ function validateLayerChecks(layerChecks, pathPrefix) {
   return issues
 }
 
+function validateSourceExistence(sourceExistence, pathPrefix, commonDecision) {
+  const issues = []
+  if (commonDecision === 'absorb') {
+    if (!sourceExistence || typeof sourceExistence !== 'object' || Array.isArray(sourceExistence)) {
+      return [issue(pathPrefix, 'source-existence-required', 'commonDecision=absorb requires sourceExistence')]
+    }
+  } else if (!sourceExistence) {
+    return issues
+  } else if (typeof sourceExistence !== 'object' || Array.isArray(sourceExistence)) {
+    return [issue(pathPrefix, 'source-existence-invalid', 'sourceExistence must be an object')]
+  }
+
+  const required = [
+    'claimedCapability',
+    'searchAnchors',
+    'sourceRoot',
+    'existenceStatus',
+    'hitEvidence',
+    'nearNeighborCoverage',
+    'ledgerDisposition',
+    'verifiedBy'
+  ]
+  for (const field of required) {
+    if (sourceExistence[field] === undefined || sourceExistence[field] === null || sourceExistence[field] === '') {
+      issues.push(issue(`${pathPrefix}.${field}`, 'source-existence-field-missing', `${field} is required on sourceExistence`))
+    }
+  }
+  if (!EXISTENCE_STATUSES.has(sourceExistence.existenceStatus)) {
+    issues.push(issue(`${pathPrefix}.existenceStatus`, 'existence-status-invalid', 'existenceStatus is invalid'))
+  }
+  if (!LEDGER_DISPOSITIONS.has(sourceExistence.ledgerDisposition)) {
+    issues.push(issue(`${pathPrefix}.ledgerDisposition`, 'ledger-disposition-invalid', 'ledgerDisposition is invalid'))
+  }
+  if (!Array.isArray(sourceExistence.searchAnchors) || sourceExistence.searchAnchors.length === 0) {
+    issues.push(issue(`${pathPrefix}.searchAnchors`, 'search-anchors-required', 'searchAnchors must be non-empty'))
+  }
+  if (!Array.isArray(sourceExistence.hitEvidence)) {
+    issues.push(issue(`${pathPrefix}.hitEvidence`, 'hit-evidence-array', 'hitEvidence must be an array'))
+  } else if (
+    COVERED_EXISTENCE.has(sourceExistence.existenceStatus) ||
+    sourceExistence.existenceStatus === 'partial'
+  ) {
+    if (sourceExistence.hitEvidence.length === 0) {
+      issues.push(issue(`${pathPrefix}.hitEvidence`, 'hit-evidence-required', 'present/partial/equivalent-covered requires hitEvidence'))
+    }
+  }
+  if (commonDecision === 'absorb') {
+    if (sourceExistence.existenceStatus === 'unverified') {
+      issues.push(issue(`${pathPrefix}.existenceStatus`, 'existence-unverified', 'cannot absorb while existenceStatus=unverified'))
+    }
+    if (COVERED_EXISTENCE.has(sourceExistence.existenceStatus)) {
+      issues.push(issue(`${pathPrefix}.existenceStatus`, 'existence-already-covered', 'present/equivalent-covered cannot use commonDecision=absorb'))
+    }
+    if (sourceExistence.ledgerDisposition === 'close-ledger') {
+      issues.push(issue(`${pathPrefix}.ledgerDisposition`, 'close-ledger-not-absorb', 'close-ledger disposition cannot absorb'))
+    }
+  }
+  return issues
+}
+
+/**
+ * Classifier for SourceExistenceVerificationGate free-text / object samples.
+ * @returns {'absorb-ok'|'residual-ok'|'close-ledger'|'ledger-status-only'|'existence-unverified'|'invalid-absorb-covered'}
+ */
+function classifySourceExistenceVerificationSample(sample) {
+  const text = typeof sample === 'string' ? sample : ''
+  const obj = sample && typeof sample === 'object' && !Array.isArray(sample) ? sample : null
+  const status = obj?.existenceStatus ||
+    (/existenceStatus\s*[:=]\s*([a-z-]+)/i.exec(text)?.[1]) ||
+    (/existenceStatus[=:]\s*([a-z-]+)/i.exec(text)?.[1])
+  const hasSearch = (Array.isArray(obj?.searchAnchors) && obj.searchAnchors.length > 0) ||
+    /searchAnchors|sourceRoot|source-root|在 source|源码检索|rg |grep /i.test(text)
+  const ledgerOnly = /状态[：:]\s*(open|active|pending)|pending absorption|只根据台账|ledger-status-only/i.test(text) && !hasSearch
+  if (ledgerOnly || (!hasSearch && /absorb|可吸纳|pure-open/i.test(text))) {
+    return 'ledger-status-only'
+  }
+  if (!hasSearch || status === 'unverified' || (!status && /未验证|unverified/i.test(text))) {
+    return 'existence-unverified'
+  }
+  if (status === 'present' || status === 'equivalent-covered' || /already-covered|already-fixed|可关账|close-ledger/i.test(text)) {
+    if (/commonDecision\s*[:=]\s*absorb|decision\s*=\s*absorb|标 absorb|整包吸纳/i.test(text) &&
+      !/不得|禁止|reject|close-ledger/i.test(text)) {
+      return 'invalid-absorb-covered'
+    }
+    return 'close-ledger'
+  }
+  if (status === 'partial' || /residual-tail|residual-candidate|补洞/i.test(text)) {
+    return 'residual-ok'
+  }
+  if (status === 'absent' || /existenceStatus\s*[:=]\s*absent|absent\b/i.test(text)) {
+    return 'absorb-ok'
+  }
+  return 'existence-unverified'
+}
+
+function validateProbeNecessity(probeNecessity, pathPrefix, commonDecision, enforcementLevel) {
+  const issues = []
+  if (commonDecision !== 'absorb') {
+    return issues
+  }
+  if (!probeNecessity || typeof probeNecessity !== 'object' || Array.isArray(probeNecessity)) {
+    return [issue(pathPrefix, 'probe-necessity-required', 'commonDecision=absorb requires probeNecessity')]
+  }
+  const required = [
+    'probeClass',
+    'necessity',
+    'rationale',
+    'probePlan',
+    'existingProbeReuse',
+    'alwaysOnImpact',
+    'complexityDelta',
+    'falsePositiveRisk'
+  ]
+  for (const field of required) {
+    if (probeNecessity[field] === undefined || probeNecessity[field] === null || probeNecessity[field] === '') {
+      issues.push(issue(`${pathPrefix}.${field}`, 'probe-necessity-field-missing', `${field} is required on probeNecessity`))
+    }
+  }
+  if (!PROBE_CLASSES.has(probeNecessity.probeClass)) {
+    issues.push(issue(`${pathPrefix}.probeClass`, 'probe-class-invalid', 'probeClass is invalid'))
+  }
+  if (!PROBE_NECESSITIES.has(probeNecessity.necessity)) {
+    issues.push(issue(`${pathPrefix}.necessity`, 'probe-necessity-invalid', 'necessity is invalid'))
+  }
+  if (!ALWAYS_ON_IMPACTS.has(probeNecessity.alwaysOnImpact)) {
+    issues.push(issue(`${pathPrefix}.alwaysOnImpact`, 'always-on-impact-invalid', 'alwaysOnImpact is invalid'))
+  }
+  if (
+    (probeNecessity.necessity === 'not-required' || probeNecessity.necessity === 'forbidden') &&
+    !probeNecessity.skipProbeReason
+  ) {
+    issues.push(issue(`${pathPrefix}.skipProbeReason`, 'skip-probe-reason-required', 'not-required/forbidden needs skipProbeReason'))
+  }
+  if (probeNecessity.necessity === 'required' && /以后|后续|待定|TODO|以后再说/i.test(String(probeNecessity.probePlan || ''))) {
+    issues.push(issue(`${pathPrefix}.probePlan`, 'probe-plan-deferred', 'required probe cannot defer probePlan'))
+  }
+  if (probeNecessity.probeClass === 'checklist-only' && commonDecision === 'absorb') {
+    issues.push(issue(`${pathPrefix}.probeClass`, 'checklist-only-not-active-absorb', 'checklist-only cannot absorb as enforceable active'))
+  }
+  if (probeNecessity.alwaysOnImpact === 'always-on-path' && !/UnaffectedIntent|base-changing|单独确认/i.test(String(probeNecessity.rationale || '') + String(probeNecessity.falsePositiveRisk || ''))) {
+    issues.push(issue(`${pathPrefix}.alwaysOnImpact`, 'always-on-needs-base-note', 'always-on-path requires base-impact note in rationale or falsePositiveRisk'))
+  }
+  if (enforcementLevel && WEAK_ENFORCEMENT.has(enforcementLevel)) {
+    issues.push(issue(`${pathPrefix.replace('probeNecessity', 'enforcementLevel')}`, 'weak-enforcement', 'absorb cannot use checklist-only/none enforcementLevel'))
+  }
+  if (enforcementLevel === 'hard-probe' && !['machine-sample', 'fixture-replay', 'extend-existing', 'structural-schema'].includes(probeNecessity.probeClass)) {
+    issues.push(issue(`${pathPrefix}.probeClass`, 'hard-probe-class-mismatch', 'hard-probe requires machine/fixture/extend/structural class'))
+  }
+  return issues
+}
+
+/**
+ * @returns {'enforceable'|'text-only-fake'|'checklist-fake'|'probe-deferred'|'ok-structural'|'ok-probe'}
+ */
+function classifyExecutableAbsorptionSample(sample) {
+  const text = typeof sample === 'string' ? sample : JSON.stringify(sample || {})
+  if (/只改 (Skill|正文|Markdown)|text-only|无消费者|无探针.*absorbed|假吸纳/i.test(text) && !/禁止|invalid|blocked/i.test(text)) {
+    return 'text-only-fake'
+  }
+  if (/checklist-only|仅清单|人工自觉/i.test(text) && /absorb|absorbed|active/i.test(text) && !/不得|禁止|否/i.test(text)) {
+    return 'checklist-fake'
+  }
+  if (/necessity\s*[:=]\s*required/i.test(text) && /以后再说|TODO|待定|后续再补探针/i.test(text)) {
+    return 'probe-deferred'
+  }
+  if (/enforcementLevel\s*[:=]\s*structural-gate|structural-schema/i.test(text)) {
+    return 'ok-structural'
+  }
+  if (/enforcementLevel\s*[:=]\s*(hard-probe|conditional-probe)|probeClass\s*[:=]\s*(machine-sample|extend-existing|fixture-replay)/i.test(text)) {
+    return 'ok-probe'
+  }
+  if (/ExecutableAbsorption|不按流程|谁会红/i.test(text) && /hard-probe|structural-gate|conditional-probe/i.test(text)) {
+    return 'enforceable'
+  }
+  return 'text-only-fake'
+}
+
 function validateCandidate(candidate, index) {
   const pathPrefix = `candidates[${index}]`
   const issues = []
@@ -87,12 +279,38 @@ function validateCandidate(candidate, index) {
   if (candidate.targetLayer && !CLASSIFICATIONS.has(candidate.targetLayer)) {
     issues.push(issue(`${pathPrefix}.targetLayer`, 'target-layer-invalid', 'targetLayer is invalid'))
   }
+  if (candidate.enforcementLevel && !ENFORCEMENT_LEVELS.has(candidate.enforcementLevel)) {
+    issues.push(issue(`${pathPrefix}.enforcementLevel`, 'enforcement-level-invalid', 'enforcementLevel is invalid'))
+  }
   if (!Array.isArray(candidate.validationRoute) || candidate.validationRoute.length === 0) {
     issues.push(issue(`${pathPrefix}.validationRoute`, 'validation-route-required', 'validationRoute must be non-empty'))
   }
   issues.push(...validateLayerChecks(candidate.layerChecks, `${pathPrefix}.layerChecks`))
-  if (candidate.commonDecision === 'absorb' && candidate.backlogClass !== 'pure-open' && !candidate.skipReason) {
-    issues.push(issue(`${pathPrefix}.skipReason`, 'non-pure-open-needs-skip', 'non pure-open candidate cannot be absorbed without skipReason'))
+  issues.push(...validateSourceExistence(candidate.sourceExistence, `${pathPrefix}.sourceExistence`, candidate.commonDecision))
+  issues.push(...validateProbeNecessity(
+    candidate.probeNecessity,
+    `${pathPrefix}.probeNecessity`,
+    candidate.commonDecision,
+    candidate.enforcementLevel
+  ))
+  if (candidate.commonDecision === 'absorb' && !candidate.enforcementLevel) {
+    issues.push(issue(`${pathPrefix}.enforcementLevel`, 'enforcement-level-required', 'absorb requires enforcementLevel'))
+  }
+  if (candidate.commonDecision === 'absorb' && WEAK_ENFORCEMENT.has(candidate.enforcementLevel)) {
+    issues.push(issue(`${pathPrefix}.enforcementLevel`, 'weak-enforcement', 'absorb cannot use checklist-only/none'))
+  }
+  if (candidate.commonDecision === 'absorb' && candidate.backlogClass !== 'pure-open' && candidate.backlogClass !== 'residual-tail' && !candidate.skipReason) {
+    issues.push(issue(`${pathPrefix}.skipReason`, 'non-pure-open-needs-skip', 'non pure-open/residual-tail candidate cannot be absorbed without skipReason'))
+  }
+  if (candidate.commonDecision === 'absorb' && candidate.backlogClass === 'residual-tail') {
+    if (candidate.sourceExistence?.existenceStatus !== 'partial') {
+      issues.push(issue(`${pathPrefix}.sourceExistence.existenceStatus`, 'residual-needs-partial', 'residual-tail absorb requires existenceStatus=partial'))
+    }
+  }
+  if (candidate.commonDecision === 'absorb' && candidate.backlogClass === 'pure-open') {
+    if (candidate.sourceExistence?.existenceStatus && candidate.sourceExistence.existenceStatus !== 'absent') {
+      issues.push(issue(`${pathPrefix}.sourceExistence.existenceStatus`, 'pure-open-needs-absent', 'pure-open absorb requires existenceStatus=absent'))
+    }
   }
   return issues
 }
@@ -153,8 +371,24 @@ function buildLayeredAbsorptionDecision(candidate) {
       prevention: candidate.prevention || null
     }
   }
-  if (candidate.backlogClass !== 'pure-open') blockers.push('backlog-class-not-pure-open')
+  if (candidate.backlogClass !== 'pure-open' && candidate.backlogClass !== 'residual-tail') {
+    blockers.push('backlog-class-not-absorbable')
+  }
   if (!candidate.targetOwner) blockers.push('target-owner-missing')
+  if (!candidate.sourceExistence) blockers.push('source-existence-missing')
+  else {
+    if (candidate.sourceExistence.existenceStatus === 'unverified') blockers.push('existence-unverified')
+    if (COVERED_EXISTENCE.has(candidate.sourceExistence.existenceStatus)) blockers.push('existence-already-covered')
+    if (candidate.backlogClass === 'pure-open' && candidate.sourceExistence.existenceStatus !== 'absent') {
+      blockers.push('pure-open-requires-absent')
+    }
+    if (candidate.backlogClass === 'residual-tail' && candidate.sourceExistence.existenceStatus !== 'partial') {
+      blockers.push('residual-requires-partial')
+    }
+  }
+  if (!candidate.probeNecessity) blockers.push('probe-necessity-missing')
+  if (!candidate.enforcementLevel) blockers.push('enforcement-level-missing')
+  if (WEAK_ENFORCEMENT.has(candidate.enforcementLevel)) blockers.push('weak-enforcement')
   for (const key of LAYER_KEYS) {
     if (candidate.layerChecks?.[key]?.state === 'blocked') blockers.push(`layer-blocked:${key}`)
   }
@@ -204,8 +438,12 @@ function planAbsorptionCandidates(matrix) {
 module.exports = {
   LAYER_KEYS,
   buildLayeredAbsorptionDecision,
+  classifyExecutableAbsorptionSample,
+  classifySourceExistenceVerificationSample,
   planAbsorptionCandidates,
   sha256,
   stableStringify,
-  validateAbsorptionCandidateMatrix
+  validateAbsorptionCandidateMatrix,
+  validateProbeNecessity,
+  validateSourceExistence
 }