gsdd-cli 0.27.0 → 0.29.0

package/bin/lib/closeout-report.mjs

@@ -1,318 +0,0 @@
-// closeout-report.mjs - read-only post-merge closure replay report
-
-import { output, parseFlagValue } from './cli-utils.mjs';
-import { buildControlMap } from './control-map.mjs';
-import { evaluateLifecyclePreflight } from './lifecycle-preflight.mjs';
-import { evaluateLifecycleState, normalizePhaseToken } from './lifecycle-state.mjs';
-import { buildPhaseVerificationReport } from './phase.mjs';
-import { resolveWorkspaceContext } from './workspace-root.mjs';
-
-const USAGE = 'Usage: gsdd closeout-report [--json] [--phase <N>]';
-
-function severityFromRisk(risk) {
-  if (risk.severity === 'block') return 'blocker';
-  if (risk.severity === 'warn') return 'warn';
-  return risk.severity || 'info';
-}
-
-function notice(source, severity, entry) {
-  return {
-    source,
-    severity,
-    code: entry.code || entry.id || 'unknown',
-    message: entry.message,
-    fix: entry.fix_hint || entry.fix || null,
-    path: entry.path || null,
-  };
-}
-
-function latestCompletedPhase(lifecycle) {
-  const completed = lifecycle.phases.filter((phase) => phase.status === 'done');
-  return completed.length > 0 ? completed[completed.length - 1] : null;
-}
-
-async function buildHealthReportSafe(ctx, args) {
-  try {
-    const health = await import('./health.mjs');
-    return health.buildHealthReport(ctx, args);
-  } catch (error) {
-    return {
-      status: 'degraded',
-      errors: [],
-      warnings: [{
-        id: 'W_CLOSEOUT_HEALTH_UNAVAILABLE',
-        severity: 'WARN',
-        message: `Health report builder unavailable in this helper runtime: ${error.message}`,
-        fix: 'Run the source CLI `gsdd health --json` for full health diagnostics, or refresh generated helper support.',
-      }],
-      info: [],
-    };
-  }
-}
-
-function summarizeControlMap(map) {
-  return {
-    status: map.risks.some((risk) => risk.severity === 'block')
-      ? 'blocked'
-      : map.risks.some((risk) => risk.severity === 'warn')
-        ? 'warnings'
-        : 'clear',
-    authority: map.authority,
-    canonical_worktree: {
-      branch: map.canonical_worktree.branch,
-      head: map.canonical_worktree.head,
-      dirty: map.canonical_worktree.dirty,
-      ahead_behind: map.canonical_worktree.ahead_behind,
-    },
-    worktree_count: map.worktrees.length,
-    risks: map.risks,
-    interventions: map.interventions,
-  };
-}
-
-function summarizePreflight(preflight) {
-  return {
-    status: preflight.status,
-    allowed: preflight.allowed,
-    reason: preflight.reason,
-    blockers: preflight.blockers,
-    warnings: preflight.warnings,
-  };
-}
-
-function summarizePhaseVerification(report) {
-  if (!report.ok) {
-    return {
-      status: 'blocked',
-      verified: false,
-      error: report.error,
-      blocked_on: ['verification'],
-    };
-  }
-  return {
-    status: report.result.verified ? 'passed' : 'blocked',
-    verified: report.result.verified,
-    phase_artifacts_present: report.result.phase_artifacts_present,
-    prerequisite_status: report.result.prerequisite_status,
-    artifact_status: report.result.artifact_status,
-    blocked_on: report.result.blocked_on,
-    blocks_verification: report.result.blocks_verification,
-  };
-}
-
-function collectBlockers({ health, preflight, phaseReport }) {
-  const blockers = [];
-  const uiProofErrors = phaseReport.result?.uiProof?.errors || [];
-  const uiProofGate = phaseReport.result?.ui_proof || {};
-
-  blockers.push(...health.errors.map((entry) => notice('health', 'blocker', entry)));
-  blockers.push(...preflight.blockers.map((entry) => notice('preflight', 'blocker', entry)));
-
-  if (!phaseReport.ok) {
-    blockers.push(notice('phase_verification', 'blocker', {
-      code: 'phase_verification_error',
-      message: phaseReport.error,
-      fix_hint: 'Run the direct verify command for the selected phase and repair the reported prerequisite.',
-    }));
-  } else {
-    for (const blockerEntry of phaseReport.result.prerequisite_status.blockers || []) {
-      blockers.push(notice('phase_verification', 'blocker', blockerEntry));
-    }
-    for (const artifact of phaseReport.result.artifact_status.unsatisfied || []) {
-      blockers.push(notice('phase_verification', 'blocker', {
-        code: 'unsatisfied_plan_artifact',
-        message: `${artifact.file} is not ${artifact.expected}.`,
-        fix_hint: artifact.fix_hint,
-        path: artifact.file,
-      }));
-    }
-    for (const entry of uiProofErrors) {
-      blockers.push(notice('ui_proof', entry.severity === 'warn' ? 'warn' : 'blocker', entry));
-    }
-    if (uiProofErrors.length === 0 && uiProofGate.blocks_verification) {
-      blockers.push(notice('ui_proof', 'blocker', {
-        code: uiProofGate.required_block || 'ui_proof_verification_failed',
-        message: `UI proof verification is required for phase ${phaseReport.result.phase} but reported status ${uiProofGate.status}.`,
-        fix_hint: 'Run the phase-specific UI proof checks and supply a passing observed proof bundle for each declared slot.',
-      }));
-    }
-  }
-
-  return blockers.filter((entry) => entry.severity === 'blocker');
-}
-
-function collectWarnings({ controlMap, health, preflight, phaseReport }) {
-  const warnings = [];
-  warnings.push(...controlMap.risks
-    .filter((risk) => risk.severity !== 'block')
-    .map((risk) => notice('control_map', severityFromRisk(risk), risk)));
-  warnings.push(...health.warnings.map((entry) => notice('health', 'warn', entry)));
-  warnings.push(...preflight.warnings
-    .filter((entry) => entry.source !== 'control-map')
-    .map((entry) => notice('preflight', entry.severity === 'info' ? 'info' : 'warn', entry)));
-  if (phaseReport.ok) {
-    warnings.push(...(phaseReport.result.uiProof?.warnings || []).map((entry) => notice('ui_proof', 'warn', entry)));
-  }
-  return warnings;
-}
-
-function nextSafeAction({ blockers, warnings, phaseNumber }) {
-  if (blockers.length > 0) {
-    return {
-      command: `gsdd verify ${phaseNumber}`,
-      reason: 'Fix blockers first, then re-run closeout replay.',
-    };
-  }
-  const hasWarn = warnings.some((entry) => entry.severity === 'warn');
-  if (warnings.length > 0 && hasWarn) {
-    const sources = new Set(warnings.filter((entry) => entry.severity === 'warn').map((entry) => entry.source));
-    if (sources.has('health')) {
-      return {
-        command: 'gsdd health --json',
-        reason: 'Resolve workspace health warnings before claiming the environment is clean.',
-      };
-    }
-    if (sources.has('ui_proof') || sources.has('phase_verification')) {
-      return {
-        command: `gsdd verify ${phaseNumber}`,
-        reason: 'Resolve phase verification warnings before claiming closeout is replay-clean.',
-      };
-    }
-    return {
-      command: 'gsdd control-map --json',
-      reason: 'Resolve local state warnings before claiming the environment is clean.',
-    };
-  }
-  if (warnings.length > 0) {
-    return {
-      command: 'gsdd control-map --json',
-      reason: 'Review the informational notices before claiming the local environment is clean.',
-    };
-  }
-  return {
-    command: `gsdd verify ${phaseNumber}`,
-    reason: 'Closeout replay is clean; run formal verification for closure if it has not already been recorded.',
-  };
-}
-
-export async function buildCloseoutReport(ctx = {}, args = []) {
-  const context = resolveWorkspaceContext(args, { cwd: ctx.cwd || process.cwd() });
-  if (context.invalid) {
-    return {
-      ok: false,
-      error: context.error,
-      exitCode: 1,
-    };
-  }
-
-  const phaseArg = parseFlagValue(context.args, '--phase');
-  if (phaseArg.invalid) {
-    return { ok: false, error: USAGE, exitCode: 1 };
-  }
-
-  const filteredArgs = context.args.filter((arg, index) => {
-    if (arg === '--json') return false;
-    if (arg === '--phase') return false;
-    if (index > 0 && context.args[index - 1] === '--phase') return false;
-    return true;
-  });
-  if (filteredArgs.length > 0) {
-    return { ok: false, error: USAGE, exitCode: 1 };
-  }
-
-  const lifecycle = evaluateLifecycleState({ planningDir: context.planningDir });
-  const selectedPhase = phaseArg.present
-    ? normalizePhaseToken(phaseArg.value)
-    : latestCompletedPhase(lifecycle)?.number || null;
-  if (!selectedPhase) {
-    return {
-      ok: false,
-      error: 'No completed phase found. Pass --phase <N> to replay a specific phase.',
-      exitCode: 1,
-    };
-  }
-
-  const controlMap = buildControlMap({
-    workspaceRoot: context.workspaceRoot,
-    planningDir: context.planningDir,
-  });
-  const health = await buildHealthReportSafe(ctx, ['--workspace-root', context.workspaceRoot]);
-  const preflight = evaluateLifecyclePreflight({
-    planningDir: context.planningDir,
-    surface: 'verify',
-    phaseNumber: selectedPhase,
-    expectsMutation: 'phase-status',
-    controlMapReport: controlMap,
-  });
-  const phaseReport = buildPhaseVerificationReport('--workspace-root', context.workspaceRoot, selectedPhase);
-  const blockers = collectBlockers({ health, preflight, phaseReport });
-  const warnings = collectWarnings({ controlMap, health, preflight, phaseReport });
-  const status = blockers.length > 0 ? 'blocked' : warnings.length > 0 ? 'warnings' : 'clear';
-
-  return {
-    ok: true,
-    exitCode: blockers.length > 0 ? 1 : 0,
-    result: {
-      schema_version: 1,
-      operation: 'closeout-report',
-      generated_at: new Date().toISOString(),
-      workspace_root: context.workspaceRoot.replace(/\\/g, '/'),
-      phase: selectedPhase,
-      scope: {
-        defaulted_to_latest_completed: !phaseArg.present,
-        latest_completed_phase: latestCompletedPhase(lifecycle)?.number || null,
-      },
-      status,
-      blockers,
-      warnings,
-      next_safe_action: nextSafeAction({ blockers, warnings, phaseNumber: selectedPhase }),
-      control_map: summarizeControlMap(controlMap),
-      health: {
-        status: health.status,
-        errors: health.errors,
-        warnings: health.warnings,
-        info: health.info,
-      },
-      preflight: summarizePreflight(preflight),
-      phase_verification: summarizePhaseVerification(phaseReport),
-      ui_proof: phaseReport.ok ? phaseReport.result.ui_proof : null,
-    },
-  };
-}
-
-function printHuman(report) {
-  console.log('gsdd closeout-report - read-only closure replay\n');
-  console.log(`Phase: ${report.phase}`);
-  console.log(`Status: ${report.status}`);
-  if (report.blockers.length > 0) {
-    console.log('\nBlockers:');
-    for (const blocker of report.blockers) {
-      console.log(`  - [${blocker.source}] ${blocker.code}: ${blocker.message}`);
-      if (blocker.fix) console.log(`    Fix: ${blocker.fix}`);
-    }
-  }
-  if (report.warnings.length > 0) {
-    console.log('\nWarnings:');
-    for (const warning of report.warnings) {
-      console.log(`  - [${warning.source}] ${warning.code}: ${warning.message}`);
-      if (warning.fix) console.log(`    Fix: ${warning.fix}`);
-    }
-  }
-  console.log(`\nNext safe action: ${report.next_safe_action.command}`);
-  console.log(`Reason: ${report.next_safe_action.reason}`);
-}
-
-export function createCmdCloseoutReport(ctx = {}) {
-  return async function cmdCloseoutReport(...args) {
-    const jsonMode = args.includes('--json');
-    const report = await buildCloseoutReport(ctx, args);
-    if (!report.ok) {
-      console.error(report.error);
-      process.exitCode = report.exitCode;
-      return;
-    }
-    if (jsonMode) output(report.result);
-    else printHuman(report.result);
-    if (report.exitCode !== 0) process.exitCode = report.exitCode;
-  };
-}

package/bin/lib/evidence-contract.mjs

@@ -1,325 +0,0 @@
-const EVIDENCE_KINDS = Object.freeze(['code', 'test', 'runtime', 'delivery', 'human']);
-const DELIVERY_POSTURES = Object.freeze(['repo_only', 'delivery_sensitive']);
-const CLOSURE_SURFACES = Object.freeze(['verify', 'audit-milestone', 'complete-milestone']);
-const RELEASE_CLAIM_POSTURES = Object.freeze([
-  'repo_closeout',
-  'runtime_validated_closeout',
-  'delivery_supported_closeout',
-]);
-
-const LEGACY_EVIDENCE_ALIASES = Object.freeze({
-  code: 'code',
-  test: 'test',
-  runtime: 'runtime',
-  delivery: 'delivery',
-  human: 'human',
-  'code-evidence': 'code',
-  'repo-test': 'test',
-  'runtime-check': 'runtime',
-  'user-confirmation': 'human',
-});
-
-const EVIDENCE_MATRIX = Object.freeze({
-  verify: Object.freeze({
-    repo_only: Object.freeze({
-      requiredKinds: Object.freeze(['code']),
-      recommendedKinds: Object.freeze(['test']),
-      blockedSoloKinds: Object.freeze(['human', 'delivery']),
-    }),
-    delivery_sensitive: Object.freeze({
-      requiredKinds: Object.freeze(['code', 'runtime', 'delivery']),
-      recommendedKinds: Object.freeze(['test', 'human']),
-      blockedSoloKinds: Object.freeze(['code', 'human']),
-    }),
-  }),
-  'audit-milestone': Object.freeze({
-    repo_only: Object.freeze({
-      requiredKinds: Object.freeze(['code', 'test']),
-      recommendedKinds: Object.freeze(['runtime', 'human']),
-      blockedSoloKinds: Object.freeze(['human', 'delivery']),
-    }),
-    delivery_sensitive: Object.freeze({
-      requiredKinds: Object.freeze(['code', 'test', 'runtime', 'delivery']),
-      recommendedKinds: Object.freeze(['human']),
-      blockedSoloKinds: Object.freeze(['code', 'human']),
-    }),
-  }),
-  'complete-milestone': Object.freeze({
-    repo_only: Object.freeze({
-      requiredKinds: Object.freeze(['code', 'test']),
-      recommendedKinds: Object.freeze(['runtime']),
-      blockedSoloKinds: Object.freeze(['human', 'delivery']),
-    }),
-    delivery_sensitive: Object.freeze({
-      requiredKinds: Object.freeze(['code', 'test', 'runtime', 'delivery']),
-      recommendedKinds: Object.freeze(['human']),
-      blockedSoloKinds: Object.freeze(['code', 'human']),
-    }),
-  }),
-});
-
-const CONTRADICTION_CATEGORIES = Object.freeze([
-  'evidence',
-  'public_surface',
-  'runtime',
-  'delivery',
-  'planning_drift',
-  'generated_surface',
-]);
-
-const CONTRADICTION_STATUSES = Object.freeze(['passed', 'failed', 'not_applicable']);
-
-const RELEASE_CLAIM_MATRIX = Object.freeze({
-  repo_closeout: Object.freeze({
-    deliveryPosture: 'repo_only',
-    requiredClaimKinds: Object.freeze([]),
-    allowedClaim: 'Repo-local milestone or phase closeout is supported by planning and repository artifacts only.',
-    invalidClaim: 'Do not imply runtime validation, delivery, publication, or public support from repo-local closeout alone.',
-  }),
-  runtime_validated_closeout: Object.freeze({
-    deliveryPosture: 'repo_only',
-    requiredClaimKinds: Object.freeze(['runtime']),
-    allowedClaim: 'Runtime behavior or a runtime surface was directly executed and observed for the named runtime or surface.',
-    invalidClaim: 'Do not generalize validation from one runtime or generated surface to another.',
-  }),
-  delivery_supported_closeout: Object.freeze({
-    deliveryPosture: 'delivery_sensitive',
-    requiredClaimKinds: Object.freeze([]),
-    allowedClaim: 'Externally consumed release, support, install, or delivery claims are supported by the delivery-sensitive evidence bar.',
-    invalidClaim: 'Do not imply merge, package, tag, GitHub Release, publication, generated-surface freshness, or public support without matching delivery evidence.',
-  }),
-});
-
-const CONTRADICTION_BLOCKERS_BY_POSTURE = Object.freeze({
-  repo_closeout: Object.freeze(['evidence', 'public_surface', 'planning_drift']),
-  runtime_validated_closeout: Object.freeze(['evidence', 'runtime', 'generated_surface', 'planning_drift']),
-  delivery_supported_closeout: CONTRADICTION_CATEGORIES,
-});
-
-export { CLOSURE_SURFACES, DELIVERY_POSTURES, EVIDENCE_KINDS, RELEASE_CLAIM_POSTURES };
-
-export function normalizeEvidenceKind(kind) {
-  if (!kind) {
-    return null;
-  }
-
-  return LEGACY_EVIDENCE_ALIASES[kind] ?? null;
-}
-
-export function normalizeEvidenceKinds(kinds = []) {
-  const normalized = [];
-  for (const kind of kinds) {
-    const resolved = normalizeEvidenceKind(kind);
-    if (resolved && !normalized.includes(resolved)) {
-      normalized.push(resolved);
-    }
-  }
-  return normalized;
-}
-
-export function isClosureSurface(surface) {
-  return CLOSURE_SURFACES.includes(surface);
-}
-
-export function normalizeReleaseClaimPosture(posture) {
-  if (!posture) return 'repo_closeout';
-  return RELEASE_CLAIM_POSTURES.includes(posture) ? posture : null;
-}
-
-export function getEvidenceContract(surface, deliveryPosture) {
-  const matrix = EVIDENCE_MATRIX[surface];
-  if (!matrix) {
-    throw new Error(`Unsupported closure evidence surface: ${surface}`);
-  }
-
-  const posture = matrix[deliveryPosture];
-  if (!posture) {
-    throw new Error(`Unsupported delivery posture for ${surface}: ${deliveryPosture}`);
-  }
-
-  return {
-    surface,
-    deliveryPosture,
-    supportedKinds: [...EVIDENCE_KINDS],
-    requiredKinds: [...posture.requiredKinds],
-    recommendedKinds: [...posture.recommendedKinds],
-    blockedSoloKinds: [...posture.blockedSoloKinds],
-  };
-}
-
-export function describeEvidenceSurface(surface) {
-  if (!isClosureSurface(surface)) {
-    return null;
-  }
-
-  return {
-    surface,
-    supportedKinds: [...EVIDENCE_KINDS],
-    deliveryPostures: DELIVERY_POSTURES.map((deliveryPosture) => getEvidenceContract(surface, deliveryPosture)),
-    releaseClaimPostures: RELEASE_CLAIM_POSTURES.map((releaseClaimPosture) => getReleaseClaimContract(surface, releaseClaimPosture)),
-  };
-}
-
-function uniqueKinds(kinds) {
-  return [...new Set(kinds)];
-}
-
-function getDowngradePosture(observedKinds) {
-  if (observedKinds.includes('runtime')) {
-    return 'runtime_validated_closeout';
-  }
-  return 'repo_closeout';
-}
-
-export function getReleaseClaimContract(surface, releaseClaimPosture = 'repo_closeout') {
-  const posture = normalizeReleaseClaimPosture(releaseClaimPosture);
-  if (!posture) {
-    throw new Error(`Unsupported release claim posture: ${releaseClaimPosture}`);
-  }
-  const claim = RELEASE_CLAIM_MATRIX[posture];
-  const evidence = getEvidenceContract(surface, claim.deliveryPosture);
-  const requiredKinds = uniqueKinds([...evidence.requiredKinds, ...claim.requiredClaimKinds]);
-
-  return {
-    surface,
-    releaseClaimPosture: posture,
-    deliveryPosture: claim.deliveryPosture,
-    supportedKinds: [...EVIDENCE_KINDS],
-    requiredKinds,
-    requiredClaimKinds: [...claim.requiredClaimKinds],
-    allowedClaim: claim.allowedClaim,
-    invalidClaim: claim.invalidClaim,
-    waiverRule: 'Waivers may only narrow the release claim posture or defer an unsupported claim; they never satisfy missing required evidence for the stronger claim.',
-    deferralRule: 'Deferrals must name the unsupported claim, missing evidence kinds, and later workflow or milestone candidate when known.',
-    contradictionCategories: [...CONTRADICTION_CATEGORIES],
-  };
-}
-
-export function evaluateReleaseClaimPosture({
-  surface,
-  releaseClaimPosture = 'repo_closeout',
-  observedKinds = [],
-  waivedKinds = [],
-} = {}) {
-  const contract = getReleaseClaimContract(surface, releaseClaimPosture);
-  const observed = normalizeEvidenceKinds(observedKinds);
-  const waived = normalizeEvidenceKinds(waivedKinds);
-  const missingKinds = contract.requiredKinds.filter((kind) => !observed.includes(kind));
-  const invalidWaivers = waived.filter((kind) => missingKinds.includes(kind));
-  const hasUnsupportedStrongClaim = contract.releaseClaimPosture !== 'repo_closeout' && missingKinds.length > 0;
-
-  return {
-    surface: contract.surface,
-    releaseClaimPosture: contract.releaseClaimPosture,
-    deliveryPosture: contract.deliveryPosture,
-    requiredKinds: [...contract.requiredKinds],
-    observedKinds: observed,
-    missingKinds,
-    invalidWaivers,
-    status: missingKinds.length === 0 && invalidWaivers.length === 0 ? 'supported' : 'unsupported',
-    disposition: hasUnsupportedStrongClaim ? 'downgrade_or_defer' : missingKinds.length > 0 ? 'block_or_defer' : 'proceed',
-    downgradeTo: hasUnsupportedStrongClaim ? getDowngradePosture(observed) : null,
-    deferredClaims: hasUnsupportedStrongClaim
-      ? [{ claim: contract.releaseClaimPosture, missingKinds }]
-      : [],
-  };
-}
-
-export function evaluateReleaseClaimCloseoutContract({
-  surface,
-  deliveryPosture = null,
-  releaseClaimPosture = 'repo_closeout',
-  observedKinds = [],
-  waivedKinds = [],
-  unsupportedClaims = [],
-  deferrals = [],
-  contradictionChecks = {},
-} = {}) {
-  const posture = evaluateReleaseClaimPosture({
-    surface,
-    releaseClaimPosture,
-    observedKinds,
-    waivedKinds,
-  });
-  const missingContradictionChecks = CONTRADICTION_CATEGORIES.filter((name) => !(name in contradictionChecks));
-  const failedContradictionChecks = Object.entries(contradictionChecks)
-    .filter(([, status]) => status === 'failed')
-    .map(([name]) => name);
-  const unknownContradictionChecks = Object.keys(contradictionChecks)
-    .filter((name) => !CONTRADICTION_CATEGORIES.includes(name));
-  const invalidContradictionChecks = Object.entries(contradictionChecks)
-    .filter(([, status]) => !CONTRADICTION_STATUSES.includes(status))
-    .map(([name]) => name);
-  const blockingContradictionChecks = failedContradictionChecks.filter((name) =>
-    CONTRADICTION_BLOCKERS_BY_POSTURE[posture.releaseClaimPosture].includes(name)
-  );
-  const unresolvedUnsupportedClaims = unsupportedClaims.filter((claim) =>
-    !deferrals.some((deferral) => namesUnsupportedClaim(deferral, claim))
-  );
-  const blockers = [];
-
-  if (deliveryPosture && deliveryPosture !== posture.deliveryPosture) {
-    blockers.push({
-      code: 'incompatible_release_claim_posture',
-      details: [`${deliveryPosture} cannot support ${posture.releaseClaimPosture}; expected ${posture.deliveryPosture}`],
-    });
-  }
-
-  if (posture.missingKinds.length > 0) {
-    blockers.push({ code: 'missing_required_release_evidence', details: posture.missingKinds });
-  }
-  if (posture.invalidWaivers.length > 0) {
-    blockers.push({ code: 'invalid_release_waivers', details: posture.invalidWaivers });
-  }
-  if (unresolvedUnsupportedClaims.length > 0) {
-    blockers.push({ code: 'unsupported_release_claims', details: unresolvedUnsupportedClaims });
-  }
-  if (missingContradictionChecks.length > 0) {
-    blockers.push({ code: 'missing_release_contradiction_checks', details: missingContradictionChecks });
-  }
-  if (unknownContradictionChecks.length > 0) {
-    blockers.push({ code: 'unknown_release_contradiction_checks', details: unknownContradictionChecks });
-  }
-  if (invalidContradictionChecks.length > 0) {
-    blockers.push({ code: 'invalid_release_contradiction_checks', details: invalidContradictionChecks });
-  }
-  if (blockingContradictionChecks.length > 0) {
-    blockers.push({ code: 'failed_release_contradiction_checks', details: blockingContradictionChecks });
-  }
-
-  return {
-    ...posture,
-    unsupportedClaims: [...unsupportedClaims],
-    deferrals: [...deferrals],
-    failedContradictionChecks: blockingContradictionChecks,
-    allFailedContradictionChecks: failedContradictionChecks,
-    missingContradictionChecks,
-    unknownContradictionChecks,
-    invalidContradictionChecks,
-    unresolvedUnsupportedClaims,
-    blockers,
-    status: blockers.length === 0 ? 'supported' : 'unsupported',
-  };
-}
-
-function namesUnsupportedClaim(deferral, claim) {
-  const normalizedDeferral = normalizeClaimText(deferral);
-  const normalizedClaim = normalizeClaimText(claim);
-  if (!normalizedDeferral || !normalizedClaim) return false;
-  return normalizedDeferral.includes(normalizedClaim) && isStructuredDeferral(normalizedDeferral);
-}
-
-function isStructuredDeferral(normalizedDeferral) {
-  const namesEvidenceKind = EVIDENCE_KINDS.some((kind) => normalizedDeferral.includes(kind));
-  const namesLaterTarget = /\b(later|next|future|workflow|milestone|phase|gsdd)\b/.test(normalizedDeferral);
-  return namesEvidenceKind && namesLaterTarget;
-}
-
-function normalizeClaimText(value) {
-  return String(value || '')
-    .trim()
-    .toLowerCase()
-    .replace(/[^a-z0-9]+/g, ' ')
-    .replace(/\s+/g, ' ')
-    .trim();
-}