@jtf19/vibecoding-kit 0.1.0

package/tools/vibe-runtime/runtime-review-envelope.mjs

@@ -0,0 +1,449 @@
+import crypto from 'node:crypto';
+import {
+  reviewFeedbackItemMetadata,
+  runtimeReviewFeedbackGate,
+} from './runtime-review-feedback-gate.mjs';
+
+const reviewStage = 'Stage 112';
+const reviewIntakeKind = 'review-intake-envelope';
+const reviewResolutionKind = 'review-resolution-envelope';
+const severityOrder = new Map([['critical', 4], ['important', 3], ['high', 3], ['medium', 2], ['low', 1], ['info', 0]]);
+
+export function runtimeReviewIntakeEnvelope({
+  review = {},
+  reviewSource = {},
+  planActionManifest = null,
+  registry = {},
+  registryDigest = '',
+} = {}) {
+  const boundaryAssertions = runtimeReviewBoundaryAssertions();
+  const reviewItems = normalizeReviewItems(review, planActionManifest);
+  const feedbackGate = runtimeReviewFeedbackGate({ review, reviewItems, sourceDigest: reviewSource.digest || '' });
+  const structureFindings = reviewStructureFindings(review, reviewItems);
+  const impactedActionItems = [...new Set(reviewItems.flatMap((item) => item.impacted_action_items))].sort();
+  const impactedFiles = [...new Set(reviewItems.flatMap((item) => item.impacted_files))].sort();
+  const requiredEvidence = [...new Set(reviewItems.flatMap((item) => item.required_evidence))].sort();
+  const blockedReasons = [
+    ...structureFindings,
+    ...reviewItems
+      .filter((item) => item.blocked)
+      .map((item) => `${item.id}: ${item.blocked_reason}`),
+  ];
+  const envelope = {
+    version: 1,
+    stage: reviewStage,
+    review_kind: reviewIntakeKind,
+    source_review: {
+      file: reviewSource.relative || reviewSource.file || '',
+      digest: reviewSource.digest || '',
+      created_at: String(review.created_at || ''),
+    },
+    source_bindings: {
+      plan_action_manifest_stage: planActionManifest?.stage || '',
+      plan_action_manifest_digest: planActionManifest?.plan_action_manifest_digest || '',
+      registry_stage: registry.registry_stage || '',
+      registry_kind: registry.registry_kind || '',
+      registry_version: registry.registry_version || 0,
+      registry_digest: registryDigest,
+    },
+    review_intake: {
+      review_file_read: Boolean(reviewSource.digest),
+      review_item_count: reviewItems.length,
+      impacted_file_count: impactedFiles.length,
+      impacted_action_item_count: impactedActionItems.length,
+      required_evidence_count: requiredEvidence.length,
+      structure_valid: structureFindings.length === 0,
+      reviewer_invoked_by_stage_112: false,
+      repair_executed_by_stage_112: false,
+      execution_authorized: false,
+    },
+    review_items: reviewItems,
+    review_feedback_gate: feedbackGate,
+    next_task_gate: feedbackGate.next_task_gate,
+    impacted_files: impactedFiles,
+    impacted_action_items: impactedActionItems,
+    required_evidence: requiredEvidence,
+    blocked: blockedReasons.length > 0,
+    blocked_reasons: blockedReasons,
+    allowed_followup: [
+      'manual review clarification outside Stage 112',
+      'manual repair outside Stage 112',
+      'review --resolution from local intake and local repair evidence files',
+    ],
+    forbidden_actions: reviewForbiddenActions(),
+    boundary_assertions: boundaryAssertions,
+    writes: false,
+    state_directory_created: false,
+    local_only: true,
+    deterministic: true,
+  };
+  const invariants = runtimeReviewIntakeInvariants(envelope);
+  return {
+    ...envelope,
+    review_intake_invariants: invariants,
+    manual_action: invariants.pass
+      ? 'Review intake is structurally usable. Stage 112 only read local review input and did not invoke a reviewer or repair code.'
+      : 'Resolve the listed review intake blockers before using this review as closeout evidence.',
+  };
+}
+
+export function runtimeReviewResolutionEnvelope({
+  reviewIntake = {},
+  reviewIntakeSource = {},
+  evidence = {},
+  evidenceSource = {},
+  registry = {},
+  registryDigest = '',
+} = {}) {
+  const boundaryAssertions = runtimeReviewBoundaryAssertions();
+  const intake = normalizeReviewIntakeEnvelope(reviewIntake);
+  const evidenceItems = normalizeResolutionEvidence(evidence);
+  const resolutionItems = intake.review_items.map((item) => resolutionItemFor(item, evidenceItems));
+  const feedbackGate = runtimeReviewFeedbackGate({ review: reviewIntake, reviewItems: intake.review_items, evidenceItems, resolutionItems, sourceDigest: reviewIntakeSource.digest || '', evidenceDigest: evidenceSource.digest || '' });
+  const missingEvidence = resolutionItems.flatMap((item) => item.missing_evidence.map((missing) => `${item.review_id}: ${missing}`));
+  const acceptedRisk = resolutionItems.filter((item) => item.accepted_risk).map((item) => item.review_id);
+  const blockedReasons = [
+    ...(intake.review_items.length > 0 ? [] : ['review intake must contain review_items']),
+    ...(evidenceItems.length > 0 ? [] : ['resolution evidence must contain evidence_items or resolutions']),
+    ...missingEvidence.map((item) => `missing resolution evidence: ${item}`),
+  ];
+  const envelope = {
+    version: 1,
+    stage: reviewStage,
+    review_kind: reviewResolutionKind,
+    source_review_intake: {
+      file: reviewIntakeSource.relative || reviewIntakeSource.file || '',
+      digest: reviewIntakeSource.digest || '',
+      review_intake_digest: intake.review_intake_digest || '',
+    },
+    source_evidence: {
+      file: evidenceSource.relative || evidenceSource.file || '',
+      digest: evidenceSource.digest || '',
+      created_at: String(evidence.created_at || ''),
+    },
+    source_bindings: {
+      registry_stage: registry.registry_stage || '',
+      registry_kind: registry.registry_kind || '',
+      registry_version: registry.registry_version || 0,
+      registry_digest: registryDigest,
+    },
+    review_resolution: {
+      review_intake_file_read: Boolean(reviewIntakeSource.digest),
+      evidence_file_read: Boolean(evidenceSource.digest),
+      resolution_item_count: resolutionItems.length,
+      resolved_count: resolutionItems.filter((item) => item.resolved).length,
+      accepted_risk_count: acceptedRisk.length,
+      missing_evidence_count: missingEvidence.length,
+      resolution_complete: resolutionItems.length > 0 && missingEvidence.length === 0,
+      reviewer_invoked_by_stage_112: false,
+      repair_executed_by_stage_112: false,
+      execution_authorized: false,
+    },
+    resolution_items: resolutionItems,
+    review_feedback_gate: feedbackGate,
+    next_task_gate: feedbackGate.next_task_gate,
+    resolved: resolutionItems.length > 0 && resolutionItems.every((item) => item.resolved || item.accepted_risk),
+    accepted_risk: acceptedRisk,
+    missing_evidence: missingEvidence,
+    blocked: blockedReasons.length > 0,
+    blocked_reasons: blockedReasons,
+    allowed_followup: [
+      'manual repair evidence collection outside Stage 112',
+      'manual risk acceptance outside Stage 112',
+      'Stage 113 TDD trace contract from local TDD trace evidence',
+    ],
+    forbidden_actions: reviewForbiddenActions(),
+    boundary_assertions: boundaryAssertions,
+    writes: false,
+    state_directory_created: false,
+    local_only: true,
+    deterministic: true,
+  };
+  const invariants = runtimeReviewResolutionInvariants(envelope);
+  return {
+    ...envelope,
+    review_resolution_invariants: invariants,
+    manual_action: invariants.pass
+      ? 'Review resolution evidence is structurally complete. Stage 112 only read local intake and evidence files.'
+      : 'Resolve the listed review resolution blockers before treating review feedback as closed.',
+  };
+}
+
+export function runtimeReviewIntakeInvariants(envelope) {
+  const boundaryFindings = reviewBoundaryFindings(envelope);
+  const findings = [
+    ...(envelope.source_review?.digest ? [] : ['missing review source digest']),
+    ...(envelope.review_items?.length > 0 ? [] : ['review_items must not be empty']),
+    ...((envelope.blocked_reasons || []).map((item) => `blocked: ${item}`)),
+    ...(envelope.review_intake?.reviewer_invoked_by_stage_112 === false ? [] : ['Stage 112 must not invoke reviewers']),
+    ...(envelope.review_intake?.repair_executed_by_stage_112 === false ? [] : ['Stage 112 must not repair code']),
+    ...(envelope.review_intake?.execution_authorized === false ? [] : ['Stage 112 intake must not authorize execution']),
+    ...boundaryFindings,
+  ];
+  return {
+    pass: findings.length === 0,
+    checked: ['local_review_source_digest', 'review_schema', 'impacted_files', 'impacted_action_items', 'required_evidence', 'no_reviewer_invocation', 'no_repair_execution', 'read_only_boundary_assertions'],
+    findings,
+  };
+}
+
+export function runtimeReviewResolutionInvariants(envelope) {
+  const boundaryFindings = reviewBoundaryFindings(envelope);
+  const findings = [
+    ...(envelope.source_review_intake?.digest ? [] : ['missing review intake source digest']),
+    ...(envelope.source_evidence?.digest ? [] : ['missing review resolution evidence source digest']),
+    ...(envelope.resolution_items?.length > 0 ? [] : ['resolution_items must not be empty']),
+    ...((envelope.blocked_reasons || []).map((item) => `blocked: ${item}`)),
+    ...(envelope.review_resolution?.reviewer_invoked_by_stage_112 === false ? [] : ['Stage 112 must not invoke reviewers']),
+    ...(envelope.review_resolution?.repair_executed_by_stage_112 === false ? [] : ['Stage 112 must not repair code']),
+    ...(envelope.review_resolution?.execution_authorized === false ? [] : ['Stage 112 resolution must not authorize execution']),
+    ...boundaryFindings,
+  ];
+  return {
+    pass: findings.length === 0,
+    checked: ['local_review_intake_source_digest', 'local_resolution_evidence_digest', 'resolution_schema', 'missing_evidence', 'accepted_risk', 'no_reviewer_invocation', 'no_repair_execution', 'read_only_boundary_assertions'],
+    findings,
+  };
+}
+
+export function runtimeReviewBoundaryAssertions() {
+  return {
+    review_intake_artifact: false,
+    review_resolution_artifact: false,
+    evidence_artifact_write: false,
+    sidecar_write: false,
+    state_directory_created: false,
+    command_execution: false,
+    check_execution: false,
+    test_execution: false,
+    verification_execution: false,
+    repair_execution: false,
+    formatting_execution: false,
+    code_generation: false,
+    reviewer_invocation: false,
+    runtime_action: false,
+    workflow_execution: false,
+    scheduler: false,
+    daemon: false,
+    retry: false,
+    git: false,
+    git_write: false,
+    commit: false,
+    pr: false,
+    push: false,
+    merge: false,
+    tag: false,
+    history_rewrite: false,
+    platform_api: false,
+    external_network: false,
+    model_invocation: false,
+    subagent: false,
+    mcp: false,
+    worktree: false,
+    business_source_write: false,
+  };
+}
+
+export function runtimeReviewIntakeDigestPayload(envelope) {
+  return {
+    stage: envelope.stage,
+    review_kind: envelope.review_kind,
+    source_review: envelope.source_review,
+    source_bindings: envelope.source_bindings,
+    review_intake: envelope.review_intake,
+    review_items: envelope.review_items,
+    review_feedback_gate: envelope.review_feedback_gate,
+    next_task_gate: envelope.next_task_gate,
+    impacted_files: envelope.impacted_files,
+    impacted_action_items: envelope.impacted_action_items,
+    required_evidence: envelope.required_evidence,
+    blocked: envelope.blocked,
+    blocked_reasons: envelope.blocked_reasons,
+    allowed_followup: envelope.allowed_followup,
+    forbidden_actions: envelope.forbidden_actions,
+    boundary_assertions: envelope.boundary_assertions,
+    review_intake_invariants: envelope.review_intake_invariants,
+  };
+}
+
+export function runtimeReviewResolutionDigestPayload(envelope) {
+  return {
+    stage: envelope.stage,
+    review_kind: envelope.review_kind,
+    source_review_intake: envelope.source_review_intake,
+    source_evidence: envelope.source_evidence,
+    source_bindings: envelope.source_bindings,
+    review_resolution: envelope.review_resolution,
+    resolution_items: envelope.resolution_items,
+    review_feedback_gate: envelope.review_feedback_gate,
+    next_task_gate: envelope.next_task_gate,
+    resolved: envelope.resolved,
+    accepted_risk: envelope.accepted_risk,
+    missing_evidence: envelope.missing_evidence,
+    blocked: envelope.blocked,
+    blocked_reasons: envelope.blocked_reasons,
+    allowed_followup: envelope.allowed_followup,
+    forbidden_actions: envelope.forbidden_actions,
+    boundary_assertions: envelope.boundary_assertions,
+    review_resolution_invariants: envelope.review_resolution_invariants,
+  };
+}
+
+export function digestReviewEnvelope(value) {
+  return crypto.createHash('sha256').update(stableStringify(value)).digest('hex');
+}
+
+function normalizeReviewItems(review, planActionManifest) {
+  const rawItems = Array.isArray(review.review_items) ? review.review_items
+    : Array.isArray(review.items) ? review.items
+      : Array.isArray(review.feedback) ? review.feedback
+        : [];
+  return rawItems.map((item, index) => {
+    const id = String(item.id || item.review_id || `stage112-review-${String(index + 1).padStart(2, '0')}`).trim();
+    const severity = normalizeSeverity(item.severity || item.priority || 'medium');
+    const impactedFiles = normalizeList(item.impacted_files || item.files || item.file).map(normalizePath).filter(Boolean).sort();
+    const impactedActionItems = normalizeList(item.impacted_action_items || item.action_items || item.action_item || inferActionItemsForFiles(impactedFiles, planActionManifest)).sort();
+    const requiredEvidence = normalizeList(item.required_evidence || item.evidence_required || item.evidence || [`resolution evidence for ${id}`]).filter(Boolean).sort();
+    const text = String(item.comment || item.feedback || item.summary || item.body || '').trim();
+    const feedbackMetadata = reviewFeedbackItemMetadata(item, { text, severity, review, requiredEvidence });
+    const blockedReason = !text ? 'review item comment is required'
+      : impactedFiles.length === 0 ? 'review item impacted_files is required'
+        : requiredEvidence.length === 0 ? 'review item required_evidence is required'
+          : '';
+    return {
+      id,
+      severity,
+      severity_rank: severityOrder.get(severity) ?? 2,
+      comment: text.slice(0, 1200),
+      impacted_files: impactedFiles,
+      impacted_action_items: impactedActionItems,
+      required_evidence: requiredEvidence,
+      ...feedbackMetadata,
+      blocked: Boolean(blockedReason),
+      blocked_reason: blockedReason,
+      reviewer_invoked_by_stage_112: false,
+      repair_executed_by_stage_112: false,
+      execution_authorized: false,
+    };
+  }).sort((left, right) => right.severity_rank - left.severity_rank || left.id.localeCompare(right.id));
+}
+
+function normalizeReviewIntakeEnvelope(value) {
+  if (value.review_intake && Array.isArray(value.review_intake.review_items)) return value.review_intake;
+  if (value.review_intake && Array.isArray(value.review_items)) return value;
+  if (value.review_intake_envelope && Array.isArray(value.review_intake_envelope.review_items)) return value.review_intake_envelope;
+  if (Array.isArray(value.review_items)) return { review_items: normalizeReviewItems(value, null), review_intake_digest: value.review_intake_digest || '' };
+  return { review_items: [], review_intake_digest: '' };
+}
+
+function normalizeResolutionEvidence(evidence) {
+  const raw = Array.isArray(evidence.resolutions) ? evidence.resolutions
+    : Array.isArray(evidence.resolution_items) ? evidence.resolution_items
+      : Array.isArray(evidence.evidence_items) ? evidence.evidence_items
+        : Array.isArray(evidence.checks) ? evidence.checks
+          : [];
+  return raw.map((item, index) => {
+    const reviewIds = normalizeList(item.review_id || item.review_ids || item.covers_review || item.coverage || item.gate_id);
+    const evidenceText = String(item.evidence || item.key_output || item.summary || item.artifact || '').trim();
+    const status = String(item.status || item.state || (item.exit_status === 0 ? 'resolved' : '')).trim().toLowerCase();
+    return {
+      id: String(item.id || `stage112-resolution-evidence-${String(index + 1).padStart(2, '0')}`).trim(),
+      review_ids: reviewIds,
+      status,
+      evidence: evidenceText.slice(0, 1200),
+      accepted_risk: item.accepted_risk === true || /accepted[_ -]?risk|risk[_ -]?accepted/.test(status),
+      resolved: /resolved|fixed|pass|passed|closed/.test(status),
+      execution_authorized: false,
+    };
+  });
+}
+
+function resolutionItemFor(reviewItem, evidenceItems) {
+  const matchingEvidence = evidenceItems.filter((item) => item.review_ids.includes(reviewItem.id));
+  const evidenceTexts = matchingEvidence.map((item) => item.evidence).filter(Boolean);
+  const acceptedRisk = matchingEvidence.some((item) => item.accepted_risk);
+  const resolved = matchingEvidence.some((item) => item.resolved) && evidenceTexts.length > 0;
+  const missingEvidence = reviewItem.required_evidence.filter((required) => !evidenceTexts.some((text) => text.toLowerCase().includes(String(required).toLowerCase())));
+  return {
+    review_id: reviewItem.id,
+    severity: reviewItem.severity,
+    impacted_files: reviewItem.impacted_files,
+    impacted_action_items: reviewItem.impacted_action_items,
+    required_evidence: reviewItem.required_evidence,
+    evidence_item_ids: matchingEvidence.map((item) => item.id),
+    resolved,
+    accepted_risk: acceptedRisk,
+    missing_evidence: acceptedRisk ? [] : missingEvidence,
+    reviewer_invoked_by_stage_112: false,
+    repair_executed_by_stage_112: false,
+    execution_authorized: false,
+  };
+}
+
+function reviewStructureFindings(review, reviewItems) {
+  const findings = [];
+  if (!review || typeof review !== 'object' || Array.isArray(review)) findings.push('review root must be a JSON object');
+  if (!String(review?.created_at || '').trim()) findings.push('created_at is required');
+  else if (Number.isNaN(Date.parse(review.created_at))) findings.push('created_at must be parseable');
+  if (!Array.isArray(review?.review_items) && !Array.isArray(review?.items) && !Array.isArray(review?.feedback)) findings.push('review_items must be an array');
+  for (const item of reviewItems) {
+    if (!item.id) findings.push('review item id is required');
+    if (item.blocked_reason) findings.push(`${item.id}: ${item.blocked_reason}`);
+  }
+  return findings;
+}
+
+function reviewBoundaryFindings(envelope) {
+  const writableBoundaries = Object.entries(envelope.boundary_assertions || {})
+    .filter(([, value]) => value !== false)
+    .map(([key]) => key);
+  const forbiddenMissing = ['review_intake_artifact', 'review_resolution_artifact', 'command_execution', 'repair_execution', 'reviewer_invocation', 'git', 'git_write', 'commit', 'push', 'pr', 'merge', 'platform_api', 'external_network', 'model_invocation', 'subagent', 'mcp', 'business_source_write']
+    .filter((key) => envelope.boundary_assertions?.[key] !== false);
+  return [
+    ...writableBoundaries.map((item) => `boundary assertion must remain false: ${item}`),
+    ...forbiddenMissing.map((item) => `forbidden boundary missing or not false: ${item}`),
+  ];
+}
+
+function reviewForbiddenActions() {
+  return [
+    'invoking reviewers, review agents, subagents, models, MCP, or platform APIs',
+    'repairing code, formatting, generating code, or mutating business source',
+    'executing commands, tests, checks, git, commit, push, PR, merge, tag, reset, checkout, or history rewrite',
+    'creating or rewriting review evidence artifacts',
+    'sidecar or .vibecoding-state write',
+    'treating review intake or resolution pass as execution permission',
+  ];
+}
+
+function inferActionItemsForFiles(files, planActionManifest) {
+  const items = Array.isArray(planActionManifest?.action_items) ? planActionManifest.action_items : [];
+  return items
+    .filter((item) => normalizeList(item.target_files).some((file) => files.includes(normalizePath(file))))
+    .map((item) => item.id || item.title)
+    .filter(Boolean);
+}
+
+function normalizeSeverity(value) {
+  const severity = String(value || '').trim().toLowerCase();
+  return severityOrder.has(severity) ? severity : 'medium';
+}
+
+function normalizeList(value) {
+  if (Array.isArray(value)) return value.flatMap((item) => normalizeList(item));
+  if (value === undefined || value === null) return [];
+  if (typeof value === 'string') return value.split(/[,\n]/).map((item) => item.trim()).filter(Boolean);
+  return [String(value).trim()].filter(Boolean);
+}
+
+function normalizePath(value) {
+  return String(value || '').trim().replace(/^"|"$/g, '').replace(/^\.\//, '').replace(/\\/g, '/');
+}
+
+function stableStringify(value) {
+  if (Array.isArray(value)) return `[${value.map((item) => stableStringify(item)).join(',')}]`;
+  if (value && typeof value === 'object') {
+    return `{${Object.keys(value).sort().map((key) => `${JSON.stringify(key)}:${stableStringify(value[key])}`).join(',')}}`;
+  }
+  return JSON.stringify(value);
+}

package/tools/vibe-runtime/runtime-review-feedback-gate.mjs

@@ -0,0 +1,160 @@
+const reviewFeedbackGateStage = 'Stage 26';
+const reviewFeedbackGateKind = 'skill-driven-review-feedback-gate';
+const reviewFeedbackCategories = Object.freeze(['blocking_bug', 'design_concern', 'test_gap', 'documentation_gap', 'disputed_feedback', 'out_of_scope_feedback']);
+const blockingSeverityRanks = new Map([['critical', 4], ['important', 3], ['high', 3], ['medium', 2], ['low', 1], ['info', 0]]);
+
+export function runtimeReviewFeedbackGate({ review = {}, reviewItems = [], evidenceItems = [], resolutionItems = [], sourceDigest = '', evidenceDigest = '' } = {}) {
+  const forbiddenClaims = forbiddenReviewFeedbackClaims(review, reviewItems);
+  const categoryCounts = Object.fromEntries(reviewFeedbackCategories.map((category) => [category, reviewItems.filter((item) => item.feedback_category === category).length]));
+  const unresolvedBlocking = reviewItems.filter((item) => item.blocks_next_task && !resolutionClearsReviewItem(item, resolutionItems));
+  const missingRequiredFields = reviewItems.flatMap((item) => reviewFeedbackRequiredFieldFindings(item));
+  const blockers = [
+    ...(sourceDigest ? [] : ['review feedback source digest is required']),
+    ...missingRequiredFields,
+    ...forbiddenClaims.map((claim) => `forbidden review feedback claim: ${claim}`),
+    ...unresolvedBlocking.map((item) => `${item.id}: blocking review feedback remains unresolved`),
+  ];
+  const phase = evidenceItems.length > 0 || resolutionItems.length > 0 ? 'resolution_check' : 'triage';
+  return {
+    version: 1,
+    stage: reviewFeedbackGateStage,
+    gate_kind: reviewFeedbackGateKind,
+    phase,
+    selected_skill: 'vibe-receiving-code-review',
+    source_bindings: {
+      review_feedback_digest: sourceDigest,
+      resolution_evidence_digest: evidenceDigest,
+    },
+    category_counts: categoryCounts,
+    feedback_items: reviewItems.map((item) => reviewFeedbackGateItem(item, resolutionItems)),
+    gate_results: reviewFeedbackGateResults({ sourceDigest, missingRequiredFields, unresolvedBlocking, forbiddenClaims }),
+    next_task_gate: nextTaskGate(blockers, unresolvedBlocking, forbiddenClaims),
+    forbidden_claim_scan: forbiddenClaims,
+    boundary_assertions: runtimeReviewFeedbackGateBoundaryAssertions(),
+    local_only: true,
+    deterministic: true,
+    writes: false,
+  };
+}
+
+export function reviewFeedbackItemMetadata(item, { text = '', severity = 'medium', review = {}, requiredEvidence = [] } = {}) {
+  const feedbackCategory = inferReviewFeedbackCategory(item, text, severity);
+  return {
+    feedback_category: feedbackCategory,
+    feedback_source: String(item.source || item.reviewer || item.author || review.source || review.reviewer || review.review_source || 'local-review-feedback-file').trim(),
+    required_change: String(item.required_change || item.requiredChange || item.action_required || item.fix || text).trim().slice(0, 1200),
+    verification_plan: normalizeList(item.verification_plan || item.validation_plan || item.required_validation || item.required_evidence || item.evidence_required || item.evidence || requiredEvidence).filter(Boolean).sort(),
+    stop_condition: String(item.stop_condition || item.stopCondition || item.blocker || 'stop before the next task until blocking review feedback has resolution evidence or accepted risk').trim(),
+    blocks_next_task: item.blocks_next_task !== undefined ? item.blocks_next_task === true : (blockingSeverityRanks.get(severity) || 0) >= 3 || feedbackCategory === 'blocking_bug' || feedbackCategory === 'test_gap',
+  };
+}
+
+function reviewFeedbackGateItem(item, resolutionItems) {
+  return {
+    id: item.id,
+    severity: item.severity,
+    feedback_category: item.feedback_category,
+    source: item.feedback_source,
+    required_change: item.required_change,
+    affected_files: item.impacted_files,
+    verification_plan: item.verification_plan,
+    stop_condition: item.stop_condition,
+    blocks_next_task: item.blocks_next_task,
+    resolved: resolutionClearsReviewItem(item, resolutionItems),
+  };
+}
+
+function reviewFeedbackGateResults({ sourceDigest, missingRequiredFields, unresolvedBlocking, forbiddenClaims }) {
+  return [
+    reviewGate('feedback_source_bound', Boolean(sourceDigest), sourceDigest ? [] : ['local review feedback source must be bound by digest']),
+    reviewGate('feedback_classified', missingRequiredFields.filter((item) => item.includes('feedback_category')).length === 0, missingRequiredFields.filter((item) => item.includes('feedback_category'))),
+    reviewGate('required_change_bound', missingRequiredFields.filter((item) => item.includes('required_change')).length === 0, missingRequiredFields.filter((item) => item.includes('required_change'))),
+    reviewGate('verification_plan_bound', missingRequiredFields.filter((item) => item.includes('verification_plan')).length === 0, missingRequiredFields.filter((item) => item.includes('verification_plan'))),
+    reviewGate('review_blocker_stops_next_task', unresolvedBlocking.length === 0, unresolvedBlocking.map((item) => `${item.id} blocks next task until resolution evidence or explicit accepted risk`)),
+    reviewGate('no_blind_repair_or_auto_reviewer', forbiddenClaims.length === 0, forbiddenClaims),
+  ];
+}
+
+function nextTaskGate(blockers, unresolvedBlocking, forbiddenClaims) {
+  return {
+    blocked: blockers.length > 0,
+    blocked_reasons: blockers,
+    override_allowed: unresolvedBlocking.length === 0 && forbiddenClaims.length === 0,
+    required_before_next_task: blockers.length > 0
+      ? ['bind review feedback source', 'classify feedback', 'bind required change and affected files', 'state verification plan', 'resolve blocking feedback or record explicit accepted risk']
+      : ['manual repair may proceed under the selected review feedback skill', 'rerun the stated verification plan before claiming resolved'],
+  };
+}
+
+function reviewGate(gate, pass, findings = []) {
+  return { gate, pass: Boolean(pass), findings };
+}
+
+function reviewFeedbackRequiredFieldFindings(item) {
+  return [
+    ...(reviewFeedbackCategories.includes(item.feedback_category) ? [] : [`${item.id}: feedback_category is required`]),
+    ...(item.feedback_source ? [] : [`${item.id}: feedback source is required`]),
+    ...(item.required_change ? [] : [`${item.id}: required_change is required`]),
+    ...(item.impacted_files.length > 0 ? [] : [`${item.id}: affected_files is required`]),
+    ...(item.verification_plan.length > 0 ? [] : [`${item.id}: verification_plan is required`]),
+    ...(item.stop_condition ? [] : [`${item.id}: stop_condition is required`]),
+  ];
+}
+
+function resolutionClearsReviewItem(item, resolutionItems) {
+  const resolution = resolutionItems.find((candidate) => candidate.review_id === item.id);
+  if (!resolution) return false;
+  return resolution.accepted_risk || (resolution.resolved && resolution.missing_evidence.length === 0);
+}
+
+function forbiddenReviewFeedbackClaims(review, reviewItems) {
+  const fields = [review.claim, review.claims, review.feedback_claim, review.resolution_claim, ...reviewItems.flatMap((item) => [item.claim, item.action_taken, item.resolution_claim])];
+  const text = normalizeList(fields).join('\n').toLowerCase();
+  if (!text) return [];
+  return [
+    [/\b(git\s+(add|commit|push|merge|tag)|gh\s+pr)\b/i, 'git or PR action claim'],
+    [/\b(subagent|reviewer|model|mcp)\s+(called|invoked|dispatched|ran)\b/i, 'reviewer, model, MCP, or subagent invocation claim'],
+    [/(auto[- ]?repair|automatically repaired|blind repair|盲修|自动修复)/i, 'blind or automatic repair claim'],
+    [/(ran tests|tests passed|verification passed|已跑测试|验证通过)/i, 'verification execution claim'],
+  ].filter(([pattern]) => pattern.test(text)).map(([, label]) => label);
+}
+
+function inferReviewFeedbackCategory(item, text, severity) {
+  const explicit = String(item.feedback_category || item.category || item.type || '').trim().toLowerCase().replace(/[ -]/g, '_');
+  if (reviewFeedbackCategories.includes(explicit)) return explicit;
+  const lower = String(text || '').toLowerCase();
+  if (/test|coverage|assert|测试|覆盖/.test(lower)) return 'test_gap';
+  if (/doc|readme|文档/.test(lower)) return 'documentation_gap';
+  if (/disagree|disputed|clarify|争议|澄清/.test(lower)) return 'disputed_feedback';
+  if (/out.of.scope|out of scope|scope|范围外/.test(lower)) return 'out_of_scope_feedback';
+  if (severity === 'critical' || severity === 'high' || severity === 'important') return 'blocking_bug';
+  return 'design_concern';
+}
+
+function runtimeReviewFeedbackGateBoundaryAssertions() {
+  return {
+    review_feedback_gate_artifact: false,
+    command_execution: false,
+    repair_execution: false,
+    reviewer_invocation: false,
+    git: false,
+    git_write: false,
+    commit: false,
+    push: false,
+    pr: false,
+    merge: false,
+    platform_api: false,
+    external_network: false,
+    model_invocation: false,
+    subagent: false,
+    mcp: false,
+    business_source_write: false,
+  };
+}
+
+function normalizeList(value) {
+  if (Array.isArray(value)) return value.flatMap((item) => normalizeList(item));
+  if (value === undefined || value === null) return [];
+  if (typeof value === 'string') return value.split(/[,\n]/).map((item) => item.trim()).filter(Boolean);
+  return [String(value).trim()].filter(Boolean);
+}