From 30f73d6ff824485b7dc660654bf7d393c3006514 Mon Sep 17 00:00:00 2001
From: Seren666 <3352221860@qq.com>
Date: Thu, 11 Jun 2026 15:46:57 +0800
Subject: [PATCH] feat: expand trust review engine

---
 .../src/components/TrustAnalysisDigest.vue    |   73 +
 frontend/src/components/TrustCenterView.vue   |    3 +
 frontend/src/components/TrustQuietReport.vue  |   54 +
 frontend/src/components/TrustReviewDetail.vue |    3 +
 frontend/src/components/trustCenterTypes.ts   |  245 +
 frontend/src/styles.css                       |  119 +
 snapgraph/trust_center.py                     |   28 +-
 snapgraph/trust_engine.py                     |  755 ++
 snapgraph/trust_engine_catalog.py             | 8398 +++++++++++++++++
 tests/test_trust_center.py                    |   42 +
 tests/trust_operations_ui.test.ts             |   21 +
 11 files changed, 9738 insertions(+), 3 deletions(-)
 create mode 100644 frontend/src/components/TrustAnalysisDigest.vue
 create mode 100644 frontend/src/components/TrustQuietReport.vue
 create mode 100644 snapgraph/trust_engine.py
 create mode 100644 snapgraph/trust_engine_catalog.py

diff --git a/frontend/src/components/TrustAnalysisDigest.vue b/frontend/src/components/TrustAnalysisDigest.vue
new file mode 100644
index 0000000..7a5e386
--- /dev/null
+++ b/frontend/src/components/TrustAnalysisDigest.vue
@@ -0,0 +1,73 @@
+<template>
+  <section v-if="analysis" class="trust-analysis-digest">
+    <div class="trust-analysis-digest-head">
+      <div>
+        <span class="section-kicker">Compressed analysis</span>
+        <strong>{{ analysis.quiet_summary }}</strong>
+      </div>
+      <span>{{ analysis.trust_score.label }} - {{ analysis.trust_score.score }}</span>
+    </div>
+
+    <p>{{ analysis.evidence_compression.summary }}</p>
+
+    <div class="trust-analysis-pills">
+      <span>{{ analysis.review_path.current_stage }}</span>
+      <span>{{ analysis.context_completeness.percent }}% context</span>
+      <span>{{ analysis.hidden_depth_count }} hidden details</span>
+    </div>
+
+    <details>
+      <summary>
+        <span>Decision impact</span>
+        <strong>{{ previewCount }} actions</strong>
+      </summary>
+      <div class="trust-analysis-impact-list">
+        <article v-for="preview in decisionPreviews" :key="preview.action">
+          <span>{{ preview.action }}</span>
+          <strong>{{ preview.summary }}</strong>
+          <p>{{ preview.recall_effect }}</p>
+        </article>
+      </div>
+    </details>
+
+    <details>
+      <summary>
+        <span>Evidence compression</span>
+        <strong>{{ analysis.evidence_compression.path_count }} paths</strong>
+      </summary>
+      <div class="trust-analysis-evidence-columns">
+        <div>
+          <span>Supporting</span>
+          <p v-for="line in analysis.evidence_compression.supporting" :key="line">{{ line }}</p>
+        </div>
+        <div>
+          <span>Needs confirmation</span>
+          <p v-for="line in analysis.evidence_compression.needs_confirmation" :key="line">{{ line }}</p>
+        </div>
+      </div>
+    </details>
+  </section>
+</template>
+
+<script setup lang="ts">
+import { computed } from 'vue'
+import type { TrustDecisionPreview, TrustReviewDetailPayload, TrustReviewStatus } from './trustCenterTypes'
+
+const props = defineProps<{
+  detail: TrustReviewDetailPayload
+}>()
+
+const analysis = computed(() => props.detail.analysis || props.detail.item.analysis)
+
+const decisionPreviews = computed(() => {
+  const previews = analysis.value?.decision_preview || {}
+  return (Object.entries(previews) as Array<[Exclude<TrustReviewStatus, 'unreviewed'>, TrustDecisionPreview]>).map(
+    ([action, preview]) => ({
+      action,
+      ...preview,
+    }),
+  )
+})
+
+const previewCount = computed(() => decisionPreviews.value.length)
+</script>
diff --git a/frontend/src/components/TrustCenterView.vue b/frontend/src/components/TrustCenterView.vue
index a3c0c43..f7595c5 100644
--- a/frontend/src/components/TrustCenterView.vue
+++ b/frontend/src/components/TrustCenterView.vue
@@ -32,6 +32,8 @@
       @mode-changed="selectedSessionMode = $event"
     />
 
+    <TrustQuietReport :session="review.session" :report="review.report" />
+
     <TrustReviewProgress
       :mode="selectedSessionMode"
       :items="sessionItems"
@@ -79,6 +81,7 @@ import { computed, ref } from 'vue'
 import TrustBatchActionBar from './TrustBatchActionBar.vue'
 import TrustDiagnosticsPanel from './TrustDiagnosticsPanel.vue'
 import TrustOpenLoopPanel from './TrustOpenLoopPanel.vue'
+import TrustQuietReport from './TrustQuietReport.vue'
 import TrustReviewProgress from './TrustReviewProgress.vue'
 import TrustReviewDetail from './TrustReviewDetail.vue'
 import TrustReviewInbox from './TrustReviewInbox.vue'
diff --git a/frontend/src/components/TrustQuietReport.vue b/frontend/src/components/TrustQuietReport.vue
new file mode 100644
index 0000000..209483e
--- /dev/null
+++ b/frontend/src/components/TrustQuietReport.vue
@@ -0,0 +1,54 @@
+<template>
+  <section v-if="report || session" class="trust-quiet-report">
+    <div>
+      <span class="section-kicker">Trust report</span>
+      <strong>{{ headline }}</strong>
+      <p>{{ quietSummary }}</p>
+    </div>
+
+    <details>
+      <summary>
+        <span>Report detail</span>
+        <strong>{{ sectionCount }} sections</strong>
+      </summary>
+      <div class="trust-quiet-report-grid">
+        <article v-for="section in visibleSections" :key="section.id">
+          <span>{{ section.title }}</span>
+          <strong>{{ section.count }}</strong>
+          <p>{{ section.summary }}</p>
+        </article>
+      </div>
+      <div v-if="visibleActions.length" class="trust-quiet-action-list">
+        <p v-for="action in visibleActions" :key="action.source_id">
+          {{ action.title }} - {{ action.risk_level }} - {{ action.summary }}
+        </p>
+      </div>
+    </details>
+  </section>
+</template>
+
+<script setup lang="ts">
+import { computed } from 'vue'
+import type { TrustReportPayload, TrustSessionPayload } from './trustCenterTypes'
+
+const props = defineProps<{
+  report?: TrustReportPayload
+  session?: TrustSessionPayload
+}>()
+
+const headline = computed(() => {
+  if (props.report?.headline) return props.report.headline
+  if (props.session?.next_step?.title) return `Next: ${props.session.next_step.title}`
+  return 'Trust context is ready.'
+})
+
+const quietSummary = computed(() => {
+  if (props.report?.quiet_summary) return props.report.quiet_summary
+  if (props.session?.quiet_summary) return props.session.quiet_summary
+  return 'Details stay collapsed so the review queue remains easy to scan.'
+})
+
+const sectionCount = computed(() => props.report?.sections.length || 0)
+const visibleSections = computed(() => props.report?.sections.slice(0, props.report.display_policy.max_visible_sections || 2) || [])
+const visibleActions = computed(() => props.report?.action_queue.slice(0, props.report.display_policy.max_visible_actions || 3) || [])
+</script>
diff --git a/frontend/src/components/TrustReviewDetail.vue b/frontend/src/components/TrustReviewDetail.vue
index 5a3c16f..4400836 100644
--- a/frontend/src/components/TrustReviewDetail.vue
+++ b/frontend/src/components/TrustReviewDetail.vue
@@ -26,6 +26,8 @@
 
       <TrustRiskLens :item="detail.item" />
 
+      <TrustAnalysisDigest :detail="detail" />
+
       <details class="trust-detail-disclosure">
         <summary>
           <span>证据路径</span>
@@ -82,6 +84,7 @@
 <script setup lang="ts">
 import { computed } from 'vue'
 import { boundaryLabel } from './trustCenterCopy'
+import TrustAnalysisDigest from './TrustAnalysisDigest.vue'
 import TrustDecisionCoach from './TrustDecisionCoach.vue'
 import TrustReviewSignals from './TrustReviewSignals.vue'
 import TrustRiskLens from './TrustRiskLens.vue'
diff --git a/frontend/src/components/trustCenterTypes.ts b/frontend/src/components/trustCenterTypes.ts
index 7d5626a..f495d43 100644
--- a/frontend/src/components/trustCenterTypes.ts
+++ b/frontend/src/components/trustCenterTypes.ts
@@ -52,6 +52,166 @@ export type TrustSignals = {
   needs_user_decision: boolean
 }
 
+export type TrustRuleMatch = {
+  rule_id: string
+  dimension: string
+  title: string
+  severity: TrustRiskLevel
+  weight: number
+  match_key: string
+  match_value: string
+  plain_language: string
+  user_question: string
+  recommended_action: string
+  evidence_prompt: string
+  reduces_pressure: boolean
+}
+
+export type TrustScore = {
+  score: number
+  label: string
+  drivers: string[]
+  score_parts: {
+    confidence: number
+    evidence: number
+    open_loops: number
+    history: number
+    boundary: string
+    status: TrustReviewStatus
+  }
+}
+
+export type TrustSignalProfile = {
+  boundary: string
+  status: TrustReviewStatus
+  risk: TrustRiskLevel
+  confidence: number
+  confidence_band: string
+  evidence_count: number
+  evidence_band: string
+  open_loop_count: number
+  loop_band: string
+  topic_count: number
+  topic_band: string
+  future_question_count: number
+  future_band: string
+  history_count: number
+  history_band: string
+  relation_counts: Record<string, number>
+  has_review_note: boolean
+  has_user_reason: boolean
+  needs_user_decision: boolean
+  is_reusable: boolean
+  is_blocked: boolean
+}
+
+export type TrustEvidenceCompression = {
+  summary: string
+  supporting: string[]
+  insufficient: string[]
+  needs_confirmation: string[]
+  supporting_count: number
+  insufficient_count: number
+  needs_confirmation_count: number
+  path_count: number
+  primary_relation: string
+  pressure_level: 'low' | 'medium' | 'high'
+  collapsed_copy: string
+}
+
+export type TrustDecisionPreview = {
+  title: string
+  tone: 'positive' | 'constructive' | 'danger' | 'neutral'
+  summary: string
+  recall_effect: string
+  graph_effect: string
+  open_loop_effect: string
+  warnings: string[]
+  confirmation_question: string
+  next_step: string
+  quiet_copy: string
+}
+
+export type TrustReviewPathStep = {
+  stage: string
+  label: string
+  instruction: string
+  evidence_hint: string
+  complete: boolean
+  current: boolean
+  fallback_action: string
+  quiet_copy: string
+}
+
+export type TrustReviewPath = {
+  current_stage: string
+  completion_percent: number
+  steps: TrustReviewPathStep[]
+  next_instruction: string
+}
+
+export type TrustSessionFit = {
+  rank: number
+  reason: string
+  recommended_mode: string
+  visible_by_default: boolean
+  can_batch: boolean
+}
+
+export type TrustImpactMap = {
+  future_recall: Array<{ question: string; impact: string }>
+  topics: Array<{ topic_id: string; title: string; role: string; impact: string }>
+  open_loops: Array<{ text: string; state: string; impact: string }>
+  graph: { evidence_count: number; impact: string }
+}
+
+export type TrustConflictReview = {
+  has_conflict: boolean
+  conflicts: string[]
+  cautions: string[]
+  resolution_prompt: string
+  quiet_copy: string
+}
+
+export type TrustContextCompleteness = {
+  percent: number
+  complete: string[]
+  missing: string[]
+  summary: string
+  quiet_copy: string
+}
+
+export type TrustAttentionBudget = {
+  max_visible_blocks: number
+  hidden_blocks: number
+  default_disclosure: string
+  reason: string
+  expand_when: string[]
+}
+
+export type TrustEngineAnalysis = {
+  source_id: string
+  trust_score: TrustScore
+  signal_profile: TrustSignalProfile
+  matched_rules: TrustRuleMatch[]
+  evidence_compression: TrustEvidenceCompression
+  decision_preview: Record<Exclude<TrustReviewStatus, 'unreviewed'>, TrustDecisionPreview>
+  review_path: TrustReviewPath
+  session_fit: TrustSessionFit
+  impact_map: TrustImpactMap
+  conflict_review: TrustConflictReview
+  context_completeness: TrustContextCompleteness
+  attention_budget: TrustAttentionBudget
+  quiet_summary: string
+  recommended_microcopy: {
+    badge: string
+    primary: string
+    secondary: string
+    empty: string
+  }
+  hidden_depth_count: number
+}
+
 export type TrustReviewItem = {
   source_id: string
   title: string
@@ -80,6 +240,7 @@ export type TrustReviewItem = {
   topic_refs: TrustTopicRef[]
   has_open_loops: boolean
   needs_review: boolean
+  analysis?: TrustEngineAnalysis
 }
 
 export type TrustSummary = {
@@ -102,6 +263,79 @@ export type TrustReviewPayload = {
   items: TrustReviewItem[]
   summary: TrustSummary
   filters: TrustReviewFilters
+  session?: TrustSessionPayload
+  report?: TrustReportPayload
+}
+
+export type TrustSessionPayload = {
+  mode: string
+  label: string
+  intent: string
+  filters: TrustReviewFilters
+  recommended_source_ids: string[]
+  visible_count: number
+  total_count: number
+  next_step: {
+    source_id: string
+    title: string
+    label: string
+    reason: string
+    action: string
+    risk_level?: TrustRiskLevel
+    remaining_after_this?: number
+  }
+  metrics: Record<string, number>
+  mode_options: Array<{
+    mode: string
+    label: string
+    intent: string
+    count: number
+    quiet_rule: string
+  }>
+  guardrails: Array<{
+    guardrail_id: string
+    surface: string
+    trigger: string
+    max_items: number
+    collapsed_label: string
+    expansion_label: string
+    reason: string
+    fallback: string
+  }>
+  completion_copy: string
+  quiet_summary: string
+}
+
+export type TrustReportPayload = {
+  headline: string
+  quiet_summary: string
+  filters: TrustReviewFilters
+  metrics: Record<string, number>
+  risk_register: Record<string, number>
+  sections: Array<{
+    id: string
+    title: string
+    priority: number
+    count: number
+    summary: string
+    detail_prompt: string
+    quiet_copy: string
+    action_label: string
+  }>
+  action_queue: Array<{
+    source_id: string
+    title: string
+    risk_level: TrustRiskLevel
+    review_status: TrustReviewStatus
+    recommended_action: string
+    summary: string
+  }>
+  display_policy: {
+    default_collapsed: boolean
+    max_visible_sections: number
+    max_visible_actions: number
+    reason: string
+  }
 }
 
 export type TrustEvidencePath = {
@@ -135,6 +369,17 @@ export type TrustSourceMapSummary = {
 
 export type TrustReviewDetailPayload = {
   item: TrustReviewItem
+  analysis?: TrustEngineAnalysis
+  report_slice?: {
+    source_id: string
+    recommended_action: string
+    score_label: string
+    score: number
+    evidence_summary: string
+    quiet_summary: string
+    primary_preview: string
+    collapsed_by_default: boolean
+  }
   evidence_paths: TrustEvidencePath[]
   history: TrustReviewHistoryItem[]
   open_loops: TrustOpenLoopItem[]
diff --git a/frontend/src/styles.css b/frontend/src/styles.css
index d938718..c071c81 100644
--- a/frontend/src/styles.css
+++ b/frontend/src/styles.css
@@ -7805,6 +7805,125 @@ button:not(:disabled):hover {
   margin: 0;
 }
 
+.trust-quiet-report,
+.trust-analysis-digest {
+  border: 1px solid rgba(55, 49, 42, 0.11);
+  background: rgba(255, 252, 246, 0.68);
+  border-radius: 8px;
+  padding: 0.8rem;
+}
+
+.trust-quiet-report {
+  display: grid;
+  gap: 0.6rem;
+}
+
+.trust-quiet-report > div:first-child,
+.trust-analysis-digest-head {
+  display: flex;
+  justify-content: space-between;
+  gap: 0.8rem;
+  align-items: flex-start;
+}
+
+.trust-quiet-report strong,
+.trust-analysis-digest strong {
+  display: block;
+  color: #2f2a24;
+  font-size: 0.96rem;
+  line-height: 1.35;
+}
+
+.trust-quiet-report p,
+.trust-analysis-digest p {
+  margin: 0.25rem 0 0;
+  color: #6f665d;
+  font-size: 0.88rem;
+  line-height: 1.45;
+}
+
+.trust-quiet-report details,
+.trust-analysis-digest details {
+  border-top: 1px solid rgba(55, 49, 42, 0.1);
+  padding-top: 0.55rem;
+}
+
+.trust-quiet-report summary,
+.trust-analysis-digest summary {
+  cursor: pointer;
+  display: flex;
+  justify-content: space-between;
+  gap: 0.75rem;
+  color: #5f574e;
+  font-size: 0.82rem;
+  list-style: none;
+}
+
+.trust-quiet-report summary::-webkit-details-marker,
+.trust-analysis-digest summary::-webkit-details-marker {
+  display: none;
+}
+
+.trust-quiet-report-grid,
+.trust-analysis-impact-list,
+.trust-analysis-evidence-columns {
+  display: grid;
+  gap: 0.55rem;
+  margin-top: 0.65rem;
+}
+
+.trust-quiet-report-grid {
+  grid-template-columns: repeat(auto-fit, minmax(180px, 1fr));
+}
+
+.trust-quiet-report-grid article,
+.trust-analysis-impact-list article,
+.trust-analysis-evidence-columns div {
+  border: 1px solid rgba(55, 49, 42, 0.09);
+  background: rgba(255, 255, 255, 0.62);
+  border-radius: 7px;
+  padding: 0.65rem;
+}
+
+.trust-quiet-action-list {
+  display: grid;
+  gap: 0.35rem;
+  margin-top: 0.6rem;
+}
+
+.trust-analysis-digest {
+  display: grid;
+  gap: 0.65rem;
+}
+
+.trust-analysis-digest-head > span {
+  white-space: nowrap;
+  border-radius: 999px;
+  padding: 0.25rem 0.5rem;
+  color: #5d5147;
+  background: rgba(138, 116, 87, 0.12);
+  font-size: 0.76rem;
+}
+
+.trust-analysis-pills {
+  display: flex;
+  flex-wrap: wrap;
+  gap: 0.35rem;
+}
+
+.trust-analysis-pills span,
+.trust-quiet-report-grid span,
+.trust-analysis-impact-list span,
+.trust-analysis-evidence-columns span {
+  color: #887b6e;
+  font-size: 0.74rem;
+  text-transform: uppercase;
+}
+
+.trust-analysis-evidence-columns {
+  grid-template-columns: repeat(auto-fit, minmax(180px, 1fr));
+}
+
 @media (max-width: 980px) {
   .trust-summary-grid,
   .trust-focus-strip,
diff --git a/snapgraph/trust_center.py b/snapgraph/trust_center.py
index 652d724..e9e5b23 100644
--- a/snapgraph/trust_center.py
+++ b/snapgraph/trust_center.py
@@ -10,6 +10,12 @@
 
 from .ingest import review_ai_inference
 from .models import DEFAULT_GRAPH_SPACE_ID
+from .trust_engine import (
+    build_detail_report_slice,
+    build_item_analysis,
+    build_report_payload,
+    build_session_payload,
+)
 from .workspace import Workspace
 
 
@@ -50,10 +56,15 @@ def list_review_items(workspace: Workspace, filters: dict | None = None) -> dict
     ]
     items = [_item for _item in items if _matches_filters(_item, filter_values)]
     items.sort(key=_review_sort_key)
+    for item in items:
+        item["analysis"] = build_item_analysis(item, peers=items)
+    summary = _summary(items)
     return {
         "items": items,
-        "summary": _summary(items),
+        "summary": summary,
         "filters": filter_values,
+        "session": build_session_payload(items, summary, filter_values),
+        "report": build_report_payload(items, summary, filter_values),
     }
 
 
@@ -63,14 +74,25 @@ def get_review_detail(workspace: Workspace, source_id: str) -> dict:
     if not payload["items"]:
         raise KeyError(source_id)
     item = payload["items"][0]
+    evidence_paths = _evidence_paths(workspace, source_id)
+    history = _history_rows(workspace, source_id)
     open_loops = [
         loop for loop in list_open_loops(workspace)["items"]
         if source_id in loop.get("source_ids", [])
     ]
+    analysis = build_item_analysis(
+        item,
+        evidence_paths=evidence_paths,
+        history=history,
+        open_loops=open_loops,
+        peers=payload["items"],
+    )
     return {
         "item": item,
-        "evidence_paths": _evidence_paths(workspace, source_id),
-        "history": _history_rows(workspace, source_id),
+        "analysis": analysis,
+        "report_slice": build_detail_report_slice(item, analysis),
+        "evidence_paths": evidence_paths,
+        "history": history,
         "open_loops": open_loops,
         "source_map": _source_map_summary(workspace, source_id),
     }
diff --git a/snapgraph/trust_engine.py b/snapgraph/trust_engine.py
new file mode 100644
index 0000000..4e8e389
--- /dev/null
+++ b/snapgraph/trust_engine.py
@@ -0,0 +1,755 @@
+from __future__ import annotations
+
+from collections import Counter
+from dataclasses import asdict
+from typing import Any
+
+from .trust_engine_catalog import (
+    first_decision_impact,
+    pressure_guardrails_for_surfaces,
+    report_sections_by_priority,
+    review_path_templates_for_stage,
+    rules_for_match,
+    session_mode_definition,
+)
+
+TRUST_ACTIONS = ("confirmed", "rewritten", "rejected", "deferred")
+RISK_ORDER = {"critical": 0, "high": 1, "medium": 2, "low": 3}
+STATUS_ORDER = {"unreviewed": 0, "deferred": 1, "rewritten": 2, "confirmed": 3, "rejected": 4}
+
+
+def build_item_analysis(
+    item: dict[str, Any],
+    *,
+    evidence_paths: list[dict[str, Any]] | None = None,
+    history: list[dict[str, Any]] | None = None,
+    open_loops: list[dict[str, Any]] | None = None,
+    peers: list[dict[str, Any]] | None = None,
+) -> dict[str, Any]:
+    paths = evidence_paths or []
+    history_rows = history or []
+    loop_rows = open_loops or []
+    peer_rows = peers or []
+    signal_profile = _signal_profile(item, paths, history_rows, loop_rows)
+    rule_matches = _matched_rules(signal_profile)
+    trust_score = _trust_score(item, signal_profile, rule_matches)
+    evidence_compression = _evidence_compression(item, paths, signal_profile)
+    decision_preview = _decision_preview(item, signal_profile, evidence_compression)
+    review_path = _review_path(item, signal_profile, evidence_compression, history_rows)
+    session_fit = _session_fit(item, peer_rows, signal_profile)
+    impact_map = _impact_map(item, signal_profile, loop_rows)
+    conflict_review = _conflict_review(item, signal_profile, paths, history_rows)
+    completeness = _context_completeness(item, signal_profile, evidence_compression)
+    quiet_summary = _quiet_summary(item, trust_score, evidence_compression, conflict_review)
+    pressure = _attention_budget(item, signal_profile, evidence_compression, history_rows, loop_rows)
+    return {
+        "source_id": item.get("source_id", ""),
+        "trust_score": trust_score,
+        "signal_profile": signal_profile,
+        "matched_rules": [_rule_payload(rule) for rule in rule_matches[:12]],
+        "evidence_compression": evidence_compression,
+        "decision_preview": decision_preview,
+        "review_path": review_path,
+        "session_fit": session_fit,
+        "impact_map": impact_map,
+        "conflict_review": conflict_review,
+        "context_completeness": completeness,
+        "attention_budget": pressure,
+        "quiet_summary": quiet_summary,
+        "recommended_microcopy": _recommended_microcopy(item, signal_profile, trust_score),
+        "hidden_depth_count": _hidden_depth_count(paths, history_rows, loop_rows, rule_matches),
+    }
+
+
+def build_session_payload(
+    items: list[dict[str, Any]],
+    summary: dict[str, Any],
+    filters: dict[str, Any] | None = None,
+    mode: str = "high-risk",
+) -> dict[str, Any]:
+    mode_spec = session_mode_definition(mode)
+    ranked = sorted(items, key=_session_sort_key)
+    recommended = [item for item in ranked if _matches_mode(item, mode_spec)]
+    if not recommended:
+        recommended = ranked
+    next_item = recommended[0] if recommended else None
+    metrics = _session_metrics(items, recommended, summary)
+    guardrails = pressure_guardrails_for_surfaces(["session", "queue", "detail", "report"])
+    mode_options = []
+    for mode_id in ["high-risk", "quick-clear", "open-loops", "all", "deferred", "ai-only", "trusted", "cleanup"]:
+        spec = session_mode_definition(mode_id)
+        count = sum(1 for item in items if _matches_mode(item, spec))
+        mode_options.append({
+            "mode": spec.mode_id,
+            "label": spec.label,
+            "intent": spec.intent,
+            "count": count,
+            "quiet_rule": spec.quiet_rule,
+        })
+    return {
+        "mode": mode_spec.mode_id,
+        "label": mode_spec.label,
+        "intent": mode_spec.intent,
+        "filters": filters or {},
+        "recommended_source_ids": [item.get("source_id", "") for item in recommended],
+        "visible_count": len(recommended),
+        "total_count": len(items),
+        "next_step": _next_step_payload(next_item, mode_spec, metrics),
+        "metrics": metrics,
+        "mode_options": mode_options,
+        "guardrails": [_guardrail_payload(guardrail) for guardrail in guardrails[:8]],
+        "completion_copy": mode_spec.completion_copy if not recommended else "The session still has useful decisions to make.",
+        "quiet_summary": _session_quiet_summary(mode_spec, metrics, next_item),
+    }
+
+
+def build_report_payload(
+    items: list[dict[str, Any]],
+    summary: dict[str, Any],
+    filters: dict[str, Any] | None = None,
+) -> dict[str, Any]:
+    risk_counts = Counter(item.get("risk_level", "low") for item in items)
+    status_counts = Counter(item.get("review_status", "unreviewed") for item in items)
+    boundary_counts = Counter(item.get("why_saved_status", "unknown") for item in items)
+    sections = []
+    metrics = {
+        "risk_count": risk_counts.get("critical", 0) + risk_counts.get("high", 0),
+        "ai_count": boundary_counts.get("AI-inferred", 0),
+        "evidence_count": sum(int(item.get("evidence_count") or 0) for item in items),
+        "loops_count": sum(1 for item in items if item.get("has_open_loops")),
+        "history_count": sum(1 for item in items if item.get("review_status") != "unreviewed"),
+        "topics_count": sum(len(item.get("topic_refs") or []) for item in items),
+        "recall_count": sum(len(item.get("future_recall_questions") or []) for item in items),
+        "decisions_count": status_counts.get("unreviewed", 0) + status_counts.get("deferred", 0),
+        "traceability_count": sum(1 for item in items if int(item.get("evidence_count") or 0) > 0),
+        "quiet_count": len(items),
+    }
+    for section in report_sections_by_priority(10):
+        count = metrics.get(section.metric_key, 0)
+        sections.append({
+            "id": section.section_id,
+            "title": section.title,
+            "priority": section.priority,
+            "count": count,
+            "summary": section.summary_template if count else section.empty_template,
+            "detail_prompt": section.detail_prompt,
+            "quiet_copy": section.quiet_copy,
+            "action_label": section.action_label,
+        })
+    action_queue = [_report_action(item) for item in sorted(items, key=_session_sort_key)[:8]]
+    headline = _report_headline(summary, risk_counts, boundary_counts)
+    return {
+        "headline": headline,
+        "quiet_summary": _report_quiet_summary(summary, risk_counts, boundary_counts),
+        "filters": filters or {},
+        "metrics": metrics,
+        "risk_register": {
+            "critical": risk_counts.get("critical", 0),
+            "high": risk_counts.get("high", 0),
+            "medium": risk_counts.get("medium", 0),
+            "low": risk_counts.get("low", 0),
+            "unreviewed": status_counts.get("unreviewed", 0),
+            "deferred": status_counts.get("deferred", 0),
+            "ai_inferred": boundary_counts.get("AI-inferred", 0),
+            "user_stated": boundary_counts.get("user-stated", 0),
+        },
+        "sections": sections,
+        "action_queue": action_queue,
+        "display_policy": {
+            "default_collapsed": True,
+            "max_visible_sections": 2,
+            "max_visible_actions": 3,
+            "reason": "The report is available for traceability but should not compete with the next review decision.",
+        },
+    }
+
+
+def build_detail_report_slice(item: dict[str, Any], analysis: dict[str, Any]) -> dict[str, Any]:
+    trust_score = analysis.get("trust_score", {})
+    evidence = analysis.get("evidence_compression", {})
+    preview = analysis.get("decision_preview", {})
+    action = item.get("recommended_action", "monitor")
+    return {
+        "source_id": item.get("source_id", ""),
+        "recommended_action": action,
+        "score_label": trust_score.get("label", "unknown"),
+        "score": trust_score.get("score", 0),
+        "evidence_summary": evidence.get("summary", ""),
+        "quiet_summary": analysis.get("quiet_summary", ""),
+        "primary_preview": preview.get("confirmed", {}).get("summary", ""),
+        "collapsed_by_default": True,
+    }
+
+
+def _signal_profile(item: dict[str, Any], evidence_paths: list[dict[str, Any]], history: list[dict[str, Any]], open_loops: list[dict[str, Any]]) -> dict[str, Any]:
+    confidence = float(item.get("confidence") or 0)
+    evidence_count = len(evidence_paths) if evidence_paths else int(item.get("evidence_count") or 0)
+    open_loop_count = len(open_loops) if open_loops else len(item.get("open_loops") or [])
+    topic_count = len(item.get("topic_refs") or [])
+    future_count = len(item.get("future_recall_questions") or [])
+    history_count = len(history)
+    relation_counts = Counter(path.get("relation", "unknown") for path in evidence_paths)
+    status = item.get("review_status", "unreviewed")
+    boundary = item.get("why_saved_status", "unknown")
+    return {
+        "boundary": boundary,
+        "status": status,
+        "risk": item.get("risk_level", "low"),
+        "confidence": confidence,
+        "confidence_band": _confidence_band(confidence),
+        "evidence_count": evidence_count,
+        "evidence_band": _evidence_band(evidence_count),
+        "open_loop_count": open_loop_count,
+        "loop_band": _loop_band(open_loop_count),
+        "topic_count": topic_count,
+        "topic_band": _topic_band(topic_count),
+        "future_question_count": future_count,
+        "future_band": "some" if future_count else "none",
+        "history_count": history_count,
+        "history_band": _history_band(history_count),
+        "relation_counts": dict(relation_counts),
+        "has_review_note": bool(str(item.get("review_note") or "").strip()),
+        "has_user_reason": boundary == "user-stated",
+        "needs_user_decision": boundary == "AI-inferred" and status in {"unreviewed", "deferred"},
+        "is_reusable": status in {"confirmed", "rewritten"},
+        "is_blocked": status == "rejected",
+    }
+
+
+def _matched_rules(profile: dict[str, Any]):
+    candidates = []
+    candidates.extend(rules_for_match("boundary", str(profile.get("boundary", "unknown"))))
+    candidates.extend(rules_for_match("status", str(profile.get("status", "unreviewed"))))
+    candidates.extend(rules_for_match("confidence", str(profile.get("confidence_band", "moderate"))))
+    candidates.extend(rules_for_match("evidence", str(profile.get("evidence_band", "none"))))
+    candidates.extend(rules_for_match("loop", str(profile.get("loop_band", "none"))))
+    candidates.extend(rules_for_match("topic", str(profile.get("topic_band", "none"))))
+    candidates.extend(rules_for_match("history", str(profile.get("history_band", "none"))))
+    candidates.extend(rules_for_match("future", str(profile.get("future_band", "none"))))
+    unique = {}
+    for rule in candidates:
+        unique.setdefault(rule.rule_id, rule)
+    return sorted(unique.values(), key=lambda rule: (-rule.weight, rule.rule_id))
+
+
+def _trust_score(item: dict[str, Any], profile: dict[str, Any], rules) -> dict[str, Any]:
+    score = 72
+    score += int(float(profile.get("confidence", 0)) * 18)
+    score += min(int(profile.get("evidence_count", 0)), 8) * 2
+    if profile.get("boundary") == "AI-inferred":
+        score -= 18
+    if profile.get("status") == "unreviewed":
+        score -= 10
+    if profile.get("status") == "deferred":
+        score -= 8
+    if profile.get("status") == "rejected":
+        score -= 30
+    if profile.get("status") in {"confirmed", "rewritten"}:
+        score += 14
+    score -= min(int(profile.get("open_loop_count", 0)), 6) * 3
+    if not profile.get("has_review_note") and item.get("risk_level") in {"critical", "high"}:
+        score -= 7
+    score = max(0, min(100, score))
+    return {
+        "score": score,
+        "label": _score_label(score),
+        "drivers": [rule.plain_language for rule in rules[:5]],
+        "score_parts": {
+            "confidence": round(float(profile.get("confidence", 0)) * 100),
+            "evidence": int(profile.get("evidence_count", 0)),
+            "open_loops": int(profile.get("open_loop_count", 0)),
+            "history": int(profile.get("history_count", 0)),
+            "boundary": profile.get("boundary", "unknown"),
+            "status": profile.get("status", "unreviewed"),
+        },
+    }
+
+
+def _evidence_compression(item: dict[str, Any], paths: list[dict[str, Any]], profile: dict[str, Any]) -> dict[str, Any]:
+    supporting = []
+    insufficient = []
+    needs_confirmation = []
+    if paths:
+        for path in paths:
+            relation = path.get("relation", "unknown")
+            line = _path_line(path)
+            if relation in {"triggered_thought", "evidence_for", "belongs_to", "derived_from", "mentions"}:
+                supporting.append(line)
+            elif relation in {"contradicts", "conflicts_with"}:
+                insufficient.append(line)
+            else:
+                needs_confirmation.append(line)
+    else:
+        count = int(profile.get("evidence_count", 0))
+        if count:
+            supporting.append(f"{count} graph evidence path(s) are available; expand detail to inspect exact paths.")
+        else:
+            insufficient.append("No graph evidence path is attached yet.")
+    if item.get("why_saved_status") == "AI-inferred":
+        needs_confirmation.append("The saved reason is model-inferred and still needs user confirmation.")
+    if item.get("open_loops"):
+        needs_confirmation.append(f"{len(item.get('open_loops') or [])} open loop(s) may change whether this reason is still useful.")
+    return {
+        "summary": _evidence_summary(supporting, insufficient, needs_confirmation, profile),
+        "supporting": supporting[:4],
+        "insufficient": insufficient[:4],
+        "needs_confirmation": needs_confirmation[:4],
+        "supporting_count": len(supporting),
+        "insufficient_count": len(insufficient),
+        "needs_confirmation_count": len(needs_confirmation),
+        "path_count": len(paths) if paths else int(profile.get("evidence_count", 0)),
+        "primary_relation": _primary_relation(paths, profile),
+        "pressure_level": _evidence_pressure(supporting, insufficient, needs_confirmation),
+        "collapsed_copy": "Evidence is compressed to decision-level signals; expand only when the decision is unclear.",
+    }
+
+
+def _decision_preview(item: dict[str, Any], profile: dict[str, Any], evidence: dict[str, Any]) -> dict[str, Any]:
+    preview = {}
+    for action in TRUST_ACTIONS:
+        impact = first_decision_impact(action)
+        warnings = list(impact.warnings)
+        if action == "confirmed" and item.get("why_saved_status") == "AI-inferred":
+            warnings.append("Confirmation will allow future recall to reuse a model-inferred reason as trusted context.")
+        if action == "rejected" and profile.get("open_loop_count", 0):
+            warnings.append("Rejecting the reason does not resolve connected open loops.")
+        if action == "rewritten" and not evidence.get("supporting"):
+            warnings.append("Rewrite should mention that graph support is currently weak.")
+        if action == "deferred" and item.get("risk_level") in {"critical", "high"}:
+            warnings.append("High-risk deferred items remain near the top of future review sessions.")
+        preview[action] = {
+            "title": impact.title,
+            "tone": impact.tone,
+            "summary": impact.summary_template,
+            "recall_effect": impact.recall_effect,
+            "graph_effect": impact.graph_effect,
+            "open_loop_effect": impact.open_loop_effect,
+            "warnings": warnings[:4],
+            "confirmation_question": impact.confirmation_question,
+            "next_step": impact.next_step,
+            "quiet_copy": impact.user_pressure,
+        }
+    return preview
+
+
+def _review_path(item: dict[str, Any], profile: dict[str, Any], evidence: dict[str, Any], history: list[dict[str, Any]]) -> dict[str, Any]:
+    stages = ["orient", "evidence", "conflict", "decision", "writeback", "followup"]
+    current_stage = _current_stage(profile, evidence, history)
+    steps = []
+    for stage in stages:
+        template = review_path_templates_for_stage(stage)[0]
+        complete = _stage_complete(stage, profile, evidence, history)
+        steps.append({
+            "stage": stage,
+            "label": template.label,
+            "instruction": template.instruction,
+            "evidence_hint": template.evidence_hint,
+            "complete": complete,
+            "current": stage == current_stage,
+            "fallback_action": template.fallback_action,
+            "quiet_copy": template.quiet_copy,
+        })
+    completed = sum(1 for step in steps if step["complete"])
+    return {
+        "current_stage": current_stage,
+        "completion_percent": round(completed / len(steps) * 100),
+        "steps": steps,
+        "next_instruction": next((step["instruction"] for step in steps if step["current"]), steps[0]["instruction"]),
+    }
+
+
+def _session_fit(item: dict[str, Any], peers: list[dict[str, Any]], profile: dict[str, Any]) -> dict[str, Any]:
+    rank = 1
+    if peers:
+        ordered = sorted(peers, key=_session_sort_key)
+        ids = [peer.get("source_id") for peer in ordered]
+        if item.get("source_id") in ids:
+            rank = ids.index(item.get("source_id")) + 1
+    if item.get("risk_level") in {"critical", "high"}:
+        reason = "This item fits the high-risk session because it can affect future answer trust."
+    elif profile.get("open_loop_count", 0):
+        reason = "This item fits an open-loop session because unresolved follow-up work remains."
+    elif profile.get("status") == "deferred":
+        reason = "This item fits a deferred session because the previous decision was postponed."
+    else:
+        reason = "This item fits a cleanup session and does not need to dominate the page."
+    return {
+        "rank": rank,
+        "reason": reason,
+        "recommended_mode": _recommended_mode(item, profile),
+        "visible_by_default": rank <= 4 or item.get("risk_level") in {"critical", "high"},
+        "can_batch": item.get("risk_level") in {"medium", "low"} and not profile.get("needs_user_decision"),
+    }
+
+
+def _impact_map(item: dict[str, Any], profile: dict[str, Any], open_loops: list[dict[str, Any]]) -> dict[str, Any]:
+    topics = item.get("topic_refs") or []
+    questions = item.get("future_recall_questions") or []
+    loops = open_loops or [{"text": text, "state": "active"} for text in item.get("open_loops") or []]
+    return {
+        "future_recall": [
+            {
+                "question": question,
+                "impact": "This question may reuse the trust decision for answer framing.",
+            }
+            for question in questions[:5]
+        ] or [{"question": "No future recall question is attached.", "impact": "Review only affects this source for now."}],
+        "topics": [
+            {
+                "topic_id": topic.get("topic_id", ""),
+                "title": topic.get("title", ""),
+                "role": topic.get("role", "evidence"),
+                "impact": "Topic recall can cite this source with the selected trust status.",
+            }
+            for topic in topics[:5]
+        ],
+        "open_loops": [
+            {
+                "text": loop.get("text", ""),
+                "state": loop.get("state", "active"),
+                "impact": "The loop remains actionable until explicitly resolved.",
+            }
+            for loop in loops[:5]
+        ],
+        "graph": {
+            "evidence_count": int(profile.get("evidence_count", 0)),
+            "impact": "Graph paths stay traceable; the trust decision changes how strongly they should be reused.",
+        },
+    }
+
+
+def _conflict_review(item: dict[str, Any], profile: dict[str, Any], paths: list[dict[str, Any]], history: list[dict[str, Any]]) -> dict[str, Any]:
+    conflicts = []
+    cautions = []
+    if item.get("review_status") == "rejected":
+        conflicts.append("The current saved reason has been rejected before.")
+    if item.get("why_saved_status") == "AI-inferred" and not profile.get("has_review_note"):
+        cautions.append("AI-inferred reason has no user review note yet.")
+    if not paths and int(profile.get("evidence_count", 0)) == 0:
+        cautions.append("No direct graph evidence path is available.")
+    if len(history) > 1:
+        cautions.append("Multiple review actions exist; read history before changing status again.")
+    for path in paths:
+        if path.get("relation") in {"contradicts", "conflicts_with"}:
+            conflicts.append(_path_line(path))
+    return {
+        "has_conflict": bool(conflicts),
+        "conflicts": conflicts[:5],
+        "cautions": cautions[:5],
+        "resolution_prompt": "Resolve conflicts only if they affect the user's future recall decision.",
+        "quiet_copy": "Conflicts stay collapsed unless present; cautions are summarized as one line.",
+    }
+
+
+def _context_completeness(item: dict[str, Any], profile: dict[str, Any], evidence: dict[str, Any]) -> dict[str, Any]:
+    checks = [
+        ("saved_reason", bool(item.get("why_saved")), "Saved reason exists"),
+        ("boundary", item.get("why_saved_status") in {"AI-inferred", "user-stated"}, "Boundary is labeled"),
+        ("evidence", bool(evidence.get("supporting")), "Evidence support exists"),
+        ("future_recall", bool(item.get("future_recall_questions")), "Future recall question exists"),
+        ("project", bool(item.get("related_project")), "Related project exists"),
+        ("review_status", item.get("review_status") != "unreviewed", "Review status has changed from default"),
+    ]
+    complete = [label for _, ok, label in checks if ok]
+    missing = [label for _, ok, label in checks if not ok]
+    percent = round(len(complete) / len(checks) * 100)
+    return {
+        "percent": percent,
+        "complete": complete,
+        "missing": missing,
+        "summary": f"{len(complete)} of {len(checks)} trust context checks are satisfied.",
+        "quiet_copy": "Only missing checks need attention; complete checks remain folded into the summary.",
+    }
+
+
+def _attention_budget(item: dict[str, Any], profile: dict[str, Any], evidence: dict[str, Any], history: list[dict[str, Any]], loops: list[dict[str, Any]]) -> dict[str, Any]:
+    visible = 2
+    if item.get("risk_level") in {"critical", "high"}:
+        visible += 1
+    if profile.get("needs_user_decision"):
+        visible += 1
+    hidden = max(0, int(profile.get("evidence_count", 0)) - len(evidence.get("supporting", [])))
+    hidden += max(0, len(history) - 2)
+    hidden += max(0, len(loops) - 2)
+    return {
+        "max_visible_blocks": min(5, visible),
+        "hidden_blocks": hidden,
+        "default_disclosure": "compressed",
+        "reason": "The page should present the next decision first and keep supporting detail available but quiet.",
+        "expand_when": [
+            "The user disputes the recommendation.",
+            "Evidence support is weak or missing.",
+            "A rejected or rewritten history exists.",
+        ],
+    }
+
+
+def _quiet_summary(item: dict[str, Any], trust_score: dict[str, Any], evidence: dict[str, Any], conflict: dict[str, Any]) -> str:
+    title = item.get("title") or "This source"
+    score = trust_score.get("label", "unknown")
+    if conflict.get("has_conflict"):
+        return f"{title} has {score} trust with a conflict to inspect before deciding."
+    if item.get("why_saved_status") == "AI-inferred":
+        return f"{title} has {score} trust; confirm the inferred reason only after scanning compressed evidence."
+    return f"{title} has {score} trust; user-stated context can stay compact unless reused broadly."
+
+
+def _recommended_microcopy(item: dict[str, Any], profile: dict[str, Any], trust_score: dict[str, Any]) -> dict[str, str]:
+    return {
+        "badge": trust_score.get("label", "unknown"),
+        "primary": _primary_microcopy(item, profile),
+        "secondary": "Details are available, but the next decision is the main thing to review.",
+        "empty": "No additional trust detail needs attention right now.",
+    }
+
+
+def _hidden_depth_count(paths: list[dict[str, Any]], history: list[dict[str, Any]], loops: list[dict[str, Any]], rules) -> int:
+    return max(0, len(paths) - 4) + max(0, len(history) - 2) + max(0, len(loops) - 2) + max(0, len(rules) - 5)
+
+
+def _session_metrics(items: list[dict[str, Any]], recommended: list[dict[str, Any]], summary: dict[str, Any]) -> dict[str, Any]:
+    risk_counts = Counter(item.get("risk_level", "low") for item in items)
+    status_counts = Counter(item.get("review_status", "unreviewed") for item in items)
+    return {
+        "total": len(items),
+        "visible": len(recommended),
+        "high_pressure": risk_counts.get("critical", 0) + risk_counts.get("high", 0),
+        "unreviewed": status_counts.get("unreviewed", 0),
+        "deferred": status_counts.get("deferred", 0),
+        "confirmed": status_counts.get("confirmed", 0),
+        "ai_inferred": int(summary.get("ai_inferred", 0)),
+        "open_loop_items": int(summary.get("open_loop_items", 0)),
+        "batchable": sum(1 for item in items if item.get("risk_level") in {"medium", "low"}),
+    }
+
+
+def _next_step_payload(item: dict[str, Any] | None, mode_spec, metrics: dict[str, Any]) -> dict[str, Any]:
+    if not item:
+        return {
+            "source_id": "",
+            "title": "",
+            "label": mode_spec.completion_copy,
+            "reason": mode_spec.empty_copy,
+            "action": "monitor",
+        }
+    return {
+        "source_id": item.get("source_id", ""),
+        "title": item.get("title", ""),
+        "label": mode_spec.next_step_copy,
+        "reason": item.get("review_focus", {}).get("detail") or mode_spec.intent,
+        "action": item.get("recommended_action", "monitor"),
+        "risk_level": item.get("risk_level", "low"),
+        "remaining_after_this": max(0, metrics.get("visible", 1) - 1),
+    }
+
+
+def _report_action(item: dict[str, Any]) -> dict[str, Any]:
+    return {
+        "source_id": item.get("source_id", ""),
+        "title": item.get("title", ""),
+        "risk_level": item.get("risk_level", "low"),
+        "review_status": item.get("review_status", "unreviewed"),
+        "recommended_action": item.get("recommended_action", "monitor"),
+        "summary": item.get("review_focus", {}).get("headline", "Review this item"),
+    }
+
+
+def _report_headline(summary: dict[str, Any], risk_counts: Counter, boundary_counts: Counter) -> str:
+    high = risk_counts.get("critical", 0) + risk_counts.get("high", 0)
+    if high:
+        return f"{high} high-priority trust decision(s) should be handled before broad cleanup."
+    ai_count = boundary_counts.get("AI-inferred", 0)
+    if ai_count:
+        return f"{ai_count} AI-inferred context(s) remain visible for light review."
+    return "Trust context is currently low pressure."
+
+
+def _report_quiet_summary(summary: dict[str, Any], risk_counts: Counter, boundary_counts: Counter) -> str:
+    total = int(summary.get("total", 0))
+    ai_count = boundary_counts.get("AI-inferred", 0)
+    high = risk_counts.get("critical", 0) + risk_counts.get("high", 0)
+    return f"{total} item(s), {ai_count} AI-inferred, {high} high-pressure; details stay collapsed by default."
+
+
+def _session_quiet_summary(mode_spec, metrics: dict[str, Any], next_item: dict[str, Any] | None) -> str:
+    if not next_item:
+        return mode_spec.empty_copy
+    return f"{mode_spec.label}: show {metrics.get('visible', 0)} item(s), start with {next_item.get('title', 'the first item')}."
+
+
+def _matches_mode(item: dict[str, Any], mode_spec) -> bool:
+    risk = item.get("risk_level", "low")
+    status = item.get("review_status", "unreviewed")
+    if mode_spec.mode_id == "open-loops":
+        return bool(item.get("has_open_loops"))
+    if mode_spec.mode_id == "ai-only":
+        return item.get("why_saved_status") == "AI-inferred" and status in mode_spec.include_statuses
+    if mode_spec.mode_id == "trusted":
+        return status in {"confirmed", "rewritten"}
+    if mode_spec.mode_id == "cleanup":
+        return status in {"rejected", "deferred"} or risk == "low"
+    return risk in mode_spec.include_risks or status in mode_spec.include_statuses
+
+
+def _session_sort_key(item: dict[str, Any]) -> tuple[int, int, int, str]:
+    return (
+        RISK_ORDER.get(item.get("risk_level", "low"), 9),
+        STATUS_ORDER.get(item.get("review_status", "unreviewed"), 9),
+        0 if item.get("needs_review") else 1,
+        str(item.get("imported_at", "")),
+    )
+
+
+def _rule_payload(rule) -> dict[str, Any]:
+    payload = asdict(rule)
+    payload.pop("report_copy", None)
+    payload.pop("quiet_copy", None)
+    return payload
+
+
+def _guardrail_payload(guardrail) -> dict[str, Any]:
+    return asdict(guardrail)
+
+
+def _confidence_band(confidence: float) -> str:
+    if confidence < 0.4:
+        return "very_low"
+    if confidence < 0.55:
+        return "low"
+    if confidence < 0.75:
+        return "moderate"
+    return "high"
+
+
+def _evidence_band(count: int) -> str:
+    if count <= 0:
+        return "none"
+    if count == 1:
+        return "single"
+    return "multiple"
+
+
+def _loop_band(count: int) -> str:
+    if count <= 0:
+        return "none"
+    if count == 1:
+        return "one"
+    return "many"
+
+
+def _topic_band(count: int) -> str:
+    if count <= 0:
+        return "none"
+    if count == 1:
+        return "one"
+    return "many"
+
+
+def _history_band(count: int) -> str:
+    if count <= 0:
+        return "none"
+    if count == 1:
+        return "one"
+    return "many"
+
+
+def _score_label(score: int) -> str:
+    if score >= 82:
+        return "stable"
+    if score >= 64:
+        return "usable"
+    if score >= 42:
+        return "needs review"
+    return "unsafe"
+
+
+def _path_line(path: dict[str, Any]) -> str:
+    source = path.get("source_label") or path.get("source_node_id") or "source"
+    relation = path.get("relation") or "related_to"
+    target = path.get("target_label") or path.get("target_node_id") or "target"
+    confidence = path.get("confidence")
+    if confidence is None:
+        return f"{source} --{relation}--> {target}"
+    return f"{source} --{relation}--> {target} ({round(float(confidence) * 100)}%)"
+
+
+def _evidence_summary(supporting: list[str], insufficient: list[str], needs_confirmation: list[str], profile: dict[str, Any]) -> str:
+    if supporting and not insufficient:
+        return f"{len(supporting)} supporting signal(s), {len(needs_confirmation)} confirmation prompt(s)."
+    if insufficient and not supporting:
+        return f"Evidence is weak: {len(insufficient)} gap(s), {len(needs_confirmation)} confirmation prompt(s)."
+    if supporting and insufficient:
+        return f"Mixed evidence: {len(supporting)} support signal(s), {len(insufficient)} gap(s)."
+    return "No evidence signal is available yet."
+
+
+def _primary_relation(paths: list[dict[str, Any]], profile: dict[str, Any]) -> str:
+    if paths:
+        counts = Counter(path.get("relation", "unknown") for path in paths)
+        return counts.most_common(1)[0][0]
+    relation_counts = profile.get("relation_counts") or {}
+    if relation_counts:
+        return max(relation_counts.items(), key=lambda item: item[1])[0]
+    return "unavailable"
+
+
+def _evidence_pressure(supporting: list[str], insufficient: list[str], needs_confirmation: list[str]) -> str:
+    if insufficient:
+        return "high"
+    if len(needs_confirmation) > len(supporting):
+        return "medium"
+    return "low"
+
+
+def _current_stage(profile: dict[str, Any], evidence: dict[str, Any], history: list[dict[str, Any]]) -> str:
+    if not profile.get("boundary"):
+        return "orient"
+    if not evidence.get("supporting"):
+        return "evidence"
+    if evidence.get("insufficient"):
+        return "conflict"
+    if profile.get("status") in {"unreviewed", "deferred"}:
+        return "decision"
+    if not history and profile.get("status") != "unreviewed":
+        return "writeback"
+    if profile.get("open_loop_count", 0):
+        return "followup"
+    return "decision"
+
+
+def _stage_complete(stage: str, profile: dict[str, Any], evidence: dict[str, Any], history: list[dict[str, Any]]) -> bool:
+    if stage == "orient":
+        return bool(profile.get("boundary"))
+    if stage == "evidence":
+        return bool(evidence.get("supporting") or evidence.get("insufficient"))
+    if stage == "conflict":
+        return not bool(evidence.get("insufficient"))
+    if stage == "decision":
+        return profile.get("status") not in {"unreviewed", "deferred"}
+    if stage == "writeback":
+        return bool(history) or profile.get("status") == "unreviewed"
+    if stage == "followup":
+        return profile.get("open_loop_count", 0) == 0
+    return False
+
+
+def _recommended_mode(item: dict[str, Any], profile: dict[str, Any]) -> str:
+    if item.get("risk_level") in {"critical", "high"}:
+        return "high-risk"
+    if profile.get("open_loop_count", 0):
+        return "open-loops"
+    if item.get("review_status") == "deferred":
+        return "deferred"
+    if item.get("why_saved_status") == "AI-inferred":
+        return "ai-only"
+    return "quick-clear"
+
+
+def _primary_microcopy(item: dict[str, Any], profile: dict[str, Any]) -> str:
+    if item.get("risk_level") in {"critical", "high"}:
+        return "Scan compressed evidence, then decide."
+    if profile.get("open_loop_count", 0):
+        return "Use the open loop to choose the next action."
+    if item.get("review_status") in {"confirmed", "rewritten"}:
+        return "Trusted enough to keep as a recall anchor."
+    return "Low pressure; batch handling is acceptable."
diff --git a/snapgraph/trust_engine_catalog.py b/snapgraph/trust_engine_catalog.py
new file mode 100644
index 0000000..e6bbbde
--- /dev/null
+++ b/snapgraph/trust_engine_catalog.py
@@ -0,0 +1,8398 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Iterable
+
+
+@dataclass(frozen=True)
+class TrustRuleDefinition:
+    rule_id: str
+    dimension: str
+    title: str
+    severity: str
+    weight: int
+    match_key: str
+    match_value: str
+    plain_language: str
+    user_question: str
+    recommended_action: str
+    quiet_copy: str
+    report_copy: str
+    evidence_prompt: str
+    reduces_pressure: bool = True
+
+
+@dataclass(frozen=True)
+class EvidenceCompressionPattern:
+    pattern_id: str
+    relation: str
+    bucket: str
+    priority: int
+    label: str
+    summary_template: str
+    reviewer_question: str
+    missing_prompt: str
+    support_copy: str
+    caution_copy: str
+    quiet_copy: str
+    report_copy: str
+
+
+@dataclass(frozen=True)
+class DecisionImpactDefinition:
+    impact_id: str
+    action: str
+    title: str
+    tone: str
+    summary_template: str
+    recall_effect: str
+    graph_effect: str
+    open_loop_effect: str
+    user_pressure: str
+    warnings: tuple[str, ...]
+    confirmation_question: str
+    next_step: str
+
+
+@dataclass(frozen=True)
+class ReviewPathTemplate:
+    template_id: str
+    stage: str
+    label: str
+    trigger: str
+    instruction: str
+    evidence_hint: str
+    completion_signal: str
+    fallback_action: str
+    quiet_copy: str
+    metric_key: str
+
+
+@dataclass(frozen=True)
+class ReportSectionDefinition:
+    section_id: str
+    title: str
+    priority: int
+    trigger: str
+    summary_template: str
+    empty_template: str
+    metric_key: str
+    detail_prompt: str
+    quiet_copy: str
+    action_label: str
+
+
+@dataclass(frozen=True)
+class SessionModeDefinition:
+    mode_id: str
+    label: str
+    intent: str
+    ordering: tuple[str, ...]
+    include_risks: tuple[str, ...]
+    include_statuses: tuple[str, ...]
+    empty_copy: str
+    next_step_copy: str
+    quiet_rule: str
+    completion_copy: str
+
+
+@dataclass(frozen=True)
+class PressureGuardrailDefinition:
+    guardrail_id: str
+    surface: str
+    trigger: str
+    max_items: int
+    collapsed_label: str
+    expansion_label: str
+    reason: str
+    fallback: str
+
+
+TRUST_RULE_DEFINITIONS: tuple[TrustRuleDefinition, ...] = (
+    TrustRuleDefinition(
+        rule_id="trule_000_boundary_AI-inferred",
+        dimension="boundary",
+        title="saved reason is AI-inferred",
+        severity="critical",
+        weight=5,
+        match_key="boundary",
+        match_value="AI-inferred",
+        plain_language="saved reason is AI-inferred; keep the review focused on user intent and source traceability.",
+        user_question="Ask whether this saved reason reflects the user, not the model.",
+        recommended_action="review_ai_inference",
+        quiet_copy="Show this as a compact signal and keep details collapsed until the user asks.",
+        report_copy="Use this signal to explain why the item belongs in the current trust queue.",
+        evidence_prompt="Compare the saved reason with source evidence before changing status.",
+        reduces_pressure=True,
+    ),
+    TrustRuleDefinition(
+        rule_id="trule_001_boundary_user-stated",
+        dimension="boundary",
+        title="saved reason was written by the user",
+        severity="high",
+        weight=6,
+        match_key="boundary",
+        match_value="user-stated",
+        plain_language="saved reason was written by the user; keep the review focused on user intent and source traceability.",
+        user_question="Protect the user-stated reason and avoid rewriting it without intent.",
+        recommended_action="preserve_user_reason",
+        quiet_copy="Show this as a compact signal and keep details collapsed until the user asks.",
+        report_copy="Use this signal to explain why the item belongs in the current trust queue.",
+        evidence_prompt="Compare the saved reason with source evidence before changing status.",
+        reduces_pressure=True,
+    ),
+    TrustRuleDefinition(
+        rule_id="trule_002_boundary_unknown",
+        dimension="boundary",
+        title="saved reason boundary is unknown",
+        severity="medium",
+        weight=7,
+        match_key="boundary",
+        match_value="unknown",
+        plain_language="saved reason boundary is unknown; keep the review focused on user intent and source traceability.",
+        user_question="Clarify whether this context came from the user or the system.",
+        recommended_action="inspect_boundary",
+        quiet_copy="Show this as a compact signal and keep details collapsed until the user asks.",
+        report_copy="Use this signal to explain why the item belongs in the current trust queue.",
+        evidence_prompt="Compare the saved reason with source evidence before changing status.",
+        reduces_pressure=True,
+    ),
+    TrustRuleDefinition(
+        rule_id="trule_003_status_unreviewed",
+        dimension="status",
+        title="review status is still unreviewed",
+        severity="high",
+        weight=8,
+        match_key="status",
+        match_value="unreviewed",
+        plain_language="review status is still unreviewed; keep the review focused on user intent and source traceability.",
+        user_question="Make a decision only after the evidence path is visible.",
+        recommended_action="review_now",
+        quiet_copy="Show this as a compact signal and keep details collapsed until the user asks.",
+        report_copy="Use this signal to explain why the item belongs in the current trust queue.",
+        evidence_prompt="Compare the saved reason with source evidence before changing status.",
+        reduces_pressure=True,
+    ),
+    TrustRuleDefinition(
+        rule_id="trule_004_status_deferred",
+        dimension="status",
+        title="previous review was deferred",
+        severity="medium",
+        weight=9,
+        match_key="status",
+        match_value="deferred",
+        plain_language="previous review was deferred; keep the review focused on user intent and source traceability.",
+        user_question="Resume the postponed decision with the smallest useful next step.",
+        recommended_action="resume_review",
+        quiet_copy="Show this as a compact signal and keep details collapsed until the user asks.",
+        report_copy="Use this signal to explain why the item belongs in the current trust queue.",
+        evidence_prompt="Compare the saved reason with source evidence before changing status.",
+        reduces_pressure=True,
+    ),
+    TrustRuleDefinition(
+        rule_id="trule_005_status_confirmed",
+        dimension="status",
+        title="this context has already been confirmed",
+        severity="low",
+        weight=10,
+        match_key="status",
+        match_value="confirmed",
+        plain_language="this context has already been confirmed; keep the review focused on user intent and source traceability.",
+        user_question="Keep it available as a trusted anchor for recall.",
+        recommended_action="monitor",
+        quiet_copy="Show this as a compact signal and keep details collapsed until the user asks.",
+        report_copy="Use this signal to explain why the item belongs in the current trust queue.",
+        evidence_prompt="Compare the saved reason with source evidence before changing status.",
+        reduces_pressure=True,
+    ),
+    TrustRuleDefinition(
+        rule_id="trule_006_status_rewritten",
+        dimension="status",
+        title="this context was rewritten by the user",
+        severity="critical",
+        weight=11,
+        match_key="status",
+        match_value="rewritten",
+        plain_language="this context was rewritten by the user; keep the review focused on user intent and source traceability.",
+        user_question="Show the rewrite as the source of truth and keep old text traceable.",
+        recommended_action="preserve_rewrite",
+        quiet_copy="Show this as a compact signal and keep details collapsed until the user asks.",
+        report_copy="Use this signal to explain why the item belongs in the current trust queue.",
+        evidence_prompt="Compare the saved reason with source evidence before changing status.",
+        reduces_pressure=True,
+    ),
+    TrustRuleDefinition(
+        rule_id="trule_007_status_rejected",
+        dimension="status",
+        title="this inference was rejected",
+        severity="high",
+        weight=12,
+        match_key="status",
+        match_value="rejected",
+        plain_language="this inference was rejected; keep the review focused on user intent and source traceability.",
+        user_question="Prevent the rejected reason from quietly returning to answers.",
+        recommended_action="inspect_rejection",
+        quiet_copy="Show this as a compact signal and keep details collapsed until the user asks.",
+        report_copy="Use this signal to explain why the item belongs in the current trust queue.",
+        evidence_prompt="Compare the saved reason with source evidence before changing status.",
+        reduces_pressure=True,
+    ),
+    TrustRuleDefinition(
+        rule_id="trule_008_confidence_very_low",
+        dimension="confidence",
+        title="confidence is below 40 percent",
+        severity="medium",
+        weight=13,
+        match_key="confidence",
+        match_value="very_low",
+        plain_language="confidence is below 40 percent; keep the review focused on user intent and source traceability.",
+        user_question="Do not let weak confidence become a stable memory.",
+        recommended_action="require_user_confirmation",
+        quiet_copy="Show this as a compact signal and keep details collapsed until the user asks.",
+        report_copy="Use this signal to explain why the item belongs in the current trust queue.",
+        evidence_prompt="Compare the saved reason with source evidence before changing status.",
+        reduces_pressure=True,
+    ),
+    TrustRuleDefinition(
+        rule_id="trule_009_confidence_low",
+        dimension="confidence",
+        title="confidence is below 55 percent",
+        severity="low",
+        weight=14,
+        match_key="confidence",
+        match_value="low",
+        plain_language="confidence is below 55 percent; keep the review focused on user intent and source traceability.",
+        user_question="Treat this as a prompt for review rather than a fact.",
+        recommended_action="require_user_confirmation",
+        quiet_copy="Show this as a compact signal and keep details collapsed until the user asks.",
+        report_copy="Use this signal to explain why the item belongs in the current trust queue.",
+        evidence_prompt="Compare the saved reason with source evidence before changing status.",
+        reduces_pressure=True,
+    ),
+    TrustRuleDefinition(
+        rule_id="trule_010_confidence_moderate",
+        dimension="confidence",
+        title="confidence is moderate",
+        severity="critical",
+        weight=15,
+        match_key="confidence",
+        match_value="moderate",
+        plain_language="confidence is moderate; keep the review focused on user intent and source traceability.",
+        user_question="Use supporting evidence before accepting the inference.",
+        recommended_action="inspect_evidence",
+        quiet_copy="Show this as a compact signal and keep details collapsed until the user asks.",
+        report_copy="Use this signal to explain why the item belongs in the current trust queue.",
+        evidence_prompt="Compare the saved reason with source evidence before changing status.",
+        reduces_pressure=True,
+    ),
+    TrustRuleDefinition(
+        rule_id="trule_011_confidence_high",
+        dimension="confidence",
+        title="confidence is high",
+        severity="high",
+        weight=16,
+        match_key="confidence",
+        match_value="high",
+        plain_language="confidence is high; keep the review focused on user intent and source traceability.",
+        user_question="A quick scan may be enough unless open loops remain.",
+        recommended_action="quick_confirm",
+        quiet_copy="Show this as a compact signal and keep details collapsed until the user asks.",
+        report_copy="Use this signal to explain why the item belongs in the current trust queue.",
+        evidence_prompt="Compare the saved reason with source evidence before changing status.",
+        reduces_pressure=True,
+    ),
+    TrustRuleDefinition(
+        rule_id="trule_012_evidence_none",
+        dimension="evidence",
+        title="no graph evidence path is attached",
+        severity="critical",
+        weight=17,
+        match_key="evidence",
+        match_value="none",
+        plain_language="no graph evidence path is attached; keep the review focused on user intent and source traceability.",
+        user_question="Do not force the user to trust an unsupported context.",
+        recommended_action="inspect_evidence",
+        quiet_copy="Show this as a compact signal and keep details collapsed until the user asks.",
+        report_copy="Use this signal to explain why the item belongs in the current trust queue.",
+        evidence_prompt="Compare the saved reason with source evidence before changing status.",
+        reduces_pressure=True,
+    ),
+    TrustRuleDefinition(
+        rule_id="trule_013_evidence_single",
+        dimension="evidence",
+        title="one graph evidence path is attached",
+        severity="high",
+        weight=18,
+        match_key="evidence",
+        match_value="single",
+        plain_language="one graph evidence path is attached; keep the review focused on user intent and source traceability.",
+        user_question="Check whether the one path is direct enough.",
+        recommended_action="inspect_path",
+        quiet_copy="Show this as a compact signal and keep details collapsed until the user asks.",
+        report_copy="Use this signal to explain why the item belongs in the current trust queue.",
+        evidence_prompt="Compare the saved reason with source evidence before changing status.",
+        reduces_pressure=True,
+    ),
+    TrustRuleDefinition(
+        rule_id="trule_014_evidence_multiple",
+        dimension="evidence",
+        title="multiple graph evidence paths are attached",
+        severity="medium",
+        weight=19,
+        match_key="evidence",
+        match_value="multiple",
+        plain_language="multiple graph evidence paths are attached; keep the review focused on user intent and source traceability.",
+        user_question="Compress the paths so the user sees the decision, not the graph noise.",
+        recommended_action="compress_paths",
+        quiet_copy="Show this as a compact signal and keep details collapsed until the user asks.",
+        report_copy="Use this signal to explain why the item belongs in the current trust queue.",
+        evidence_prompt="Compare the saved reason with source evidence before changing status.",
+        reduces_pressure=True,
+    ),
+    TrustRuleDefinition(
+        rule_id="trule_015_loop_none",
+        dimension="loop",
+        title="no open loop remains connected",
+        severity="low",
+        weight=20,
+        match_key="loop",
+        match_value="none",
+        plain_language="no open loop remains connected; keep the review focused on user intent and source traceability.",
+        user_question="This item can be handled as a memory quality decision.",
+        recommended_action="review_context",
+        quiet_copy="Show this as a compact signal and keep details collapsed until the user asks.",
+        report_copy="Use this signal to explain why the item belongs in the current trust queue.",
+        evidence_prompt="Compare the saved reason with source evidence before changing status.",
+        reduces_pressure=True,
+    ),
+    TrustRuleDefinition(
+        rule_id="trule_016_loop_one",
+        dimension="loop",
+        title="one open loop remains connected",
+        severity="critical",
+        weight=21,
+        match_key="loop",
+        match_value="one",
+        plain_language="one open loop remains connected; keep the review focused on user intent and source traceability.",
+        user_question="Decide whether the unresolved loop is still worth carrying.",
+        recommended_action="triage_open_loop",
+        quiet_copy="Show this as a compact signal and keep details collapsed until the user asks.",
+        report_copy="Use this signal to explain why the item belongs in the current trust queue.",
+        evidence_prompt="Compare the saved reason with source evidence before changing status.",
+        reduces_pressure=True,
+    ),
+    TrustRuleDefinition(
+        rule_id="trule_017_loop_many",
+        dimension="loop",
+        title="multiple open loops remain connected",
+        severity="high",
+        weight=5,
+        match_key="loop",
+        match_value="many",
+        plain_language="multiple open loops remain connected; keep the review focused on user intent and source traceability.",
+        user_question="Group unresolved work before asking the user to decide.",
+        recommended_action="group_open_loops",
+        quiet_copy="Show this as a compact signal and keep details collapsed until the user asks.",
+        report_copy="Use this signal to explain why the item belongs in the current trust queue.",
+        evidence_prompt="Compare the saved reason with source evidence before changing status.",
+        reduces_pressure=True,
+    ),
+    TrustRuleDefinition(
+        rule_id="trule_018_topic_none",
+        dimension="topic",
+        title="no topic currently references this source",
+        severity="low",
+        weight=6,
+        match_key="topic",
+        match_value="none",
+        plain_language="no topic currently references this source; keep the review focused on user intent and source traceability.",
+        user_question="The context may be isolated and should not dominate recall.",
+        recommended_action="inspect_topic",
+        quiet_copy="Show this as a compact signal and keep details collapsed until the user asks.",
+        report_copy="Use this signal to explain why the item belongs in the current trust queue.",
+        evidence_prompt="Compare the saved reason with source evidence before changing status.",
+        reduces_pressure=True,
+    ),
+    TrustRuleDefinition(
+        rule_id="trule_019_topic_one",
+        dimension="topic",
+        title="one topic references this source",
+        severity="critical",
+        weight=7,
+        match_key="topic",
+        match_value="one",
+        plain_language="one topic references this source; keep the review focused on user intent and source traceability.",
+        user_question="Check the source against the topic that will reuse it.",
+        recommended_action="inspect_topic",
+        quiet_copy="Show this as a compact signal and keep details collapsed until the user asks.",
+        report_copy="Use this signal to explain why the item belongs in the current trust queue.",
+        evidence_prompt="Compare the saved reason with source evidence before changing status.",
+        reduces_pressure=True,
+    ),
+    TrustRuleDefinition(
+        rule_id="trule_020_topic_many",
+        dimension="topic",
+        title="multiple topics reference this source",
+        severity="high",
+        weight=8,
+        match_key="topic",
+        match_value="many",
+        plain_language="multiple topics reference this source; keep the review focused on user intent and source traceability.",
+        user_question="Treat the source as a cross-topic trust anchor.",
+        recommended_action="inspect_bridge",
+        quiet_copy="Show this as a compact signal and keep details collapsed until the user asks.",
+        report_copy="Use this signal to explain why the item belongs in the current trust queue.",
+        evidence_prompt="Compare the saved reason with source evidence before changing status.",
+        reduces_pressure=True,
+    ),
+    TrustRuleDefinition(
+        rule_id="trule_021_history_none",
+        dimension="history",
+        title="no review history exists",
+        severity="critical",
+        weight=9,
+        match_key="history",
+        match_value="none",
+        plain_language="no review history exists; keep the review focused on user intent and source traceability.",
+        user_question="Ask for the smallest possible first decision.",
+        recommended_action="first_review",
+        quiet_copy="Show this as a compact signal and keep details collapsed until the user asks.",
+        report_copy="Use this signal to explain why the item belongs in the current trust queue.",
+        evidence_prompt="Compare the saved reason with source evidence before changing status.",
+        reduces_pressure=True,
+    ),
+    TrustRuleDefinition(
+        rule_id="trule_022_history_one",
+        dimension="history",
+        title="one review action exists",
+        severity="high",
+        weight=10,
+        match_key="history",
+        match_value="one",
+        plain_language="one review action exists; keep the review focused on user intent and source traceability.",
+        user_question="Show the last action before asking for another.",
+        recommended_action="resume_from_history",
+        quiet_copy="Show this as a compact signal and keep details collapsed until the user asks.",
+        report_copy="Use this signal to explain why the item belongs in the current trust queue.",
+        evidence_prompt="Compare the saved reason with source evidence before changing status.",
+        reduces_pressure=True,
+    ),
+    TrustRuleDefinition(
+        rule_id="trule_023_history_many",
+        dimension="history",
+        title="multiple review actions exist",
+        severity="medium",
+        weight=11,
+        match_key="history",
+        match_value="many",
+        plain_language="multiple review actions exist; keep the review focused on user intent and source traceability.",
+        user_question="Summarize the timeline to avoid decision fatigue.",
+        recommended_action="compress_history",
+        quiet_copy="Show this as a compact signal and keep details collapsed until the user asks.",
+        report_copy="Use this signal to explain why the item belongs in the current trust queue.",
+        evidence_prompt="Compare the saved reason with source evidence before changing status.",
+        reduces_pressure=True,
+    ),
+    TrustRuleDefinition(
+        rule_id="trule_024_future_none",
+        dimension="future",
+        title="no future recall question is attached",
+        severity="medium",
+        weight=12,
+        match_key="future",
+        match_value="none",
+        plain_language="no future recall question is attached; keep the review focused on user intent and source traceability.",
+        user_question="Clarify how this memory will help later.",
+        recommended_action="add_future_question",
+        quiet_copy="Show this as a compact signal and keep details collapsed until the user asks.",
+        report_copy="Use this signal to explain why the item belongs in the current trust queue.",
+        evidence_prompt="Compare the saved reason with source evidence before changing status.",
+        reduces_pressure=True,
+    ),
+    TrustRuleDefinition(
+        rule_id="trule_025_future_some",
+        dimension="future",
+        title="future recall questions are attached",
+        severity="low",
+        weight=13,
+        match_key="future",
+        match_value="some",
+        plain_language="future recall questions are attached; keep the review focused on user intent and source traceability.",
+        user_question="Use the questions to explain why review matters.",
+        recommended_action="connect_to_recall",
+        quiet_copy="Show this as a compact signal and keep details collapsed until the user asks.",
+        report_copy="Use this signal to explain why the item belongs in the current trust queue.",
+        evidence_prompt="Compare the saved reason with source evidence before changing status.",
+        reduces_pressure=True,
+    ),
+    TrustRuleDefinition(
+        rule_id="trule_026_source_map_missing",
+        dimension="source_map",
+        title="source node traceability is missing",
+        severity="critical",
+        weight=14,
+        match_key="source_map",
+        match_value="missing",
+        plain_language="source node traceability is missing; keep the review focused on user intent and source traceability.",
+        user_question="Avoid treating the memory as fully grounded.",
+        recommended_action="repair_traceability",
+        quiet_copy="Show this as a compact signal and keep details collapsed until the user asks.",
+        report_copy="Use this signal to explain why the item belongs in the current trust queue.",
+        evidence_prompt="Compare the saved reason with source evidence before changing status.",
+        reduces_pressure=True,
+    ),
+    TrustRuleDefinition(
+        rule_id="trule_027_source_map_present",
+        dimension="source_map",
+        title="source node traceability is present",
+        severity="high",
+        weight=15,
+        match_key="source_map",
+        match_value="present",
+        plain_language="source node traceability is present; keep the review focused on user intent and source traceability.",
+        user_question="Keep traceability visible but collapsed.",
+        recommended_action="preserve_traceability",
+        quiet_copy="Show this as a compact signal and keep details collapsed until the user asks.",
+        report_copy="Use this signal to explain why the item belongs in the current trust queue.",
+        evidence_prompt="Compare the saved reason with source evidence before changing status.",
+        reduces_pressure=True,
+    ),
+    TrustRuleDefinition(
+        rule_id="trule_028_boundary_AI-inferred",
+        dimension="boundary",
+        title="saved reason is AI-inferred",
+        severity="critical",
+        weight=16,
+        match_key="boundary",
+        match_value="AI-inferred",
+        plain_language="saved reason is AI-inferred; keep the review focused on user intent and source traceability.",
+        user_question="Ask whether this saved reason reflects the user, not the model.",
+        recommended_action="review_ai_inference",
+        quiet_copy="Show this as a compact signal and keep details collapsed until the user asks.",
+        report_copy="Use this signal to explain why the item belongs in the current trust queue.",
+        evidence_prompt="Compare the saved reason with source evidence before changing status.",
+        reduces_pressure=True,
+    ),
+    TrustRuleDefinition(
+        rule_id="trule_029_boundary_user-stated",
+        dimension="boundary",
+        title="saved reason was written by the user",
+        severity="high",
+        weight=17,
+        match_key="boundary",
+        match_value="user-stated",
+        plain_language="saved reason was written by the user; keep the review focused on user intent and source traceability.",
+        user_question="Protect the user-stated reason and avoid rewriting it without intent.",
+        recommended_action="preserve_user_reason",
+        quiet_copy="Show this as a compact signal and keep details collapsed until the user asks.",
+        report_copy="Use this signal to explain why the item belongs in the current trust queue.",
+        evidence_prompt="Compare the saved reason with source evidence before changing status.",
+        reduces_pressure=True,
+    ),
+    TrustRuleDefinition(
+        rule_id="trule_030_boundary_unknown",
+        dimension="boundary",
+        title="saved reason boundary is unknown",
+        severity="medium",
+        weight=18,
+        match_key="boundary",
+        match_value="unknown",
+        plain_language="saved reason boundary is unknown; keep the review focused on user intent and source traceability.",
+        user_question="Clarify whether this context came from the user or the system.",
+        recommended_action="inspect_boundary",
+        quiet_copy="Show this as a compact signal and keep details collapsed until the user asks.",
+        report_copy="Use this signal to explain why the item belongs in the current trust queue.",
+        evidence_prompt="Compare the saved reason with source evidence before changing status.",
+        reduces_pressure=True,
+    ),
+    TrustRuleDefinition(
+        rule_id="trule_031_status_unreviewed",
+        dimension="status",
+        title="review status is still unreviewed",
+        severity="high",
+        weight=19,
+        match_key="status",
+        match_value="unreviewed",
+        plain_language="review status is still unreviewed; keep the review focused on user intent and source traceability.",
+        user_question="Make a decision only after the evidence path is visible.",
+        recommended_action="review_now",
+        quiet_copy="Show this as a compact signal and keep details collapsed until the user asks.",
+        report_copy="Use this signal to explain why the item belongs in the current trust queue.",
+        evidence_prompt="Compare the saved reason with source evidence before changing status.",
+        reduces_pressure=True,
+    ),
+    TrustRuleDefinition(
+        rule_id="trule_032_status_deferred",
+        dimension="status",
+        title="previous review was deferred",
+        severity="medium",
+        weight=20,
+        match_key="status",
+        match_value="deferred",
+        plain_language="previous review was deferred; keep the review focused on user intent and source traceability.",
+        user_question="Resume the postponed decision with the smallest useful next step.",
+        recommended_action="resume_review",
+        quiet_copy="Show this as a compact signal and keep details collapsed until the user asks.",
+        report_copy="Use this signal to explain why the item belongs in the current trust queue.",
+        evidence_prompt="Compare the saved reason with source evidence before changing status.",
+        reduces_pressure=True,
+    ),
+    TrustRuleDefinition(
+        rule_id="trule_033_status_confirmed",
+        dimension="status",
+        title="this context has already been confirmed",
+        severity="low",
+        weight=21,
+        match_key="status",
+        match_value="confirmed",
+        plain_language="this context has already been confirmed; keep the review focused on user intent and source traceability.",
+        user_question="Keep it available as a trusted anchor for recall.",
+        recommended_action="monitor",
+        quiet_copy="Show this as a compact signal and keep details collapsed until the user asks.",
+        report_copy="Use this signal to explain why the item belongs in the current trust queue.",
+        evidence_prompt="Compare the saved reason with source evidence before changing status.",
+        reduces_pressure=True,
+    ),
+    TrustRuleDefinition(
+        rule_id="trule_034_status_rewritten",
+        dimension="status",
+        title="this context was rewritten by the user",
+        severity="critical",
+        weight=5,
+        match_key="status",
+        match_value="rewritten",
+        plain_language="this context was rewritten by the user; keep the review focused on user intent and source traceability.",
+        user_question="Show the rewrite as the source of truth and keep old text traceable.",
+        recommended_action="preserve_rewrite",
+        quiet_copy="Show this as a compact signal and keep details collapsed until the user asks.",
+        report_copy="Use this signal to explain why the item belongs in the current trust queue.",
+        evidence_prompt="Compare the saved reason with source evidence before changing status.",
+        reduces_pressure=True,
+    ),
+    TrustRuleDefinition(
+        rule_id="trule_035_status_rejected",
+        dimension="status",
+        title="this inference was rejected",
+        severity="high",
+        weight=6,
+        match_key="status",
+        match_value="rejected",
+        plain_language="this inference was rejected; keep the review focused on user intent and source traceability.",
+        user_question="Prevent the rejected reason from quietly returning to answers.",
+        recommended_action="inspect_rejection",
+        quiet_copy="Show this as a compact signal and keep details collapsed until the user asks.",
+        report_copy="Use this signal to explain why the item belongs in the current trust queue.",
+        evidence_prompt="Compare the saved reason with source evidence before changing status.",
+        reduces_pressure=True,
+    ),
+    TrustRuleDefinition(
+        rule_id="trule_036_confidence_very_low",
+        dimension="confidence",
+        title="confidence is below 40 percent",
+        severity="medium",
+        weight=7,
+        match_key="confidence",
+        match_value="very_low",
+        plain_language="confidence is below 40 percent; keep the review focused on user intent and source traceability.",
+        user_question="Do not let weak confidence become a stable memory.",
+        recommended_action="require_user_confirmation",
+        quiet_copy="Show this as a compact signal and keep details collapsed until the user asks.",
+        report_copy="Use this signal to explain why the item belongs in the current trust queue.",
+        evidence_prompt="Compare the saved reason with source evidence before changing status.",
+        reduces_pressure=True,
+    ),
+    TrustRuleDefinition(
+        rule_id="trule_037_confidence_low",
+        dimension="confidence",
+        title="confidence is below 55 percent",
+        severity="low",
+        weight=8,
+        match_key="confidence",
+        match_value="low",
+        plain_language="confidence is below 55 percent; keep the review focused on user intent and source traceability.",
+        user_question="Treat this as a prompt for review rather than a fact.",
+        recommended_action="require_user_confirmation",
+        quiet_copy="Show this as a compact signal and keep details collapsed until the user asks.",
+        report_copy="Use this signal to explain why the item belongs in the current trust queue.",
+        evidence_prompt="Compare the saved reason with source evidence before changing status.",
+        reduces_pressure=True,
+    ),
+    TrustRuleDefinition(
+        rule_id="trule_038_confidence_moderate",
+        dimension="confidence",
+        title="confidence is moderate",
+        severity="critical",
+        weight=9,
+        match_key="confidence",
+        match_value="moderate",
+        plain_language="confidence is moderate; keep the review focused on user intent and source traceability.",
+        user_question="Use supporting evidence before accepting the inference.",
+        recommended_action="inspect_evidence",
+        quiet_copy="Show this as a compact signal and keep details collapsed until the user asks.",
+        report_copy="Use this signal to explain why the item belongs in the current trust queue.",
+        evidence_prompt="Compare the saved reason with source evidence before changing status.",
+        reduces_pressure=True,
+    ),
+    TrustRuleDefinition(
+        rule_id="trule_039_confidence_high",
+        dimension="confidence",
+        title="confidence is high",
+        severity="high",
+        weight=10,
+        match_key="confidence",
+        match_value="high",
+        plain_language="confidence is high; keep the review focused on user intent and source traceability.",
+        user_question="A quick scan may be enough unless open loops remain.",
+        recommended_action="quick_confirm",
+        quiet_copy="Show this as a compact signal and keep details collapsed until the user asks.",
+        report_copy="Use this signal to explain why the item belongs in the current trust queue.",
+        evidence_prompt="Compare the saved reason with source evidence before changing status.",
+        reduces_pressure=True,
+    ),
+    TrustRuleDefinition(
+        rule_id="trule_040_evidence_none",
+        dimension="evidence",
+        title="no graph evidence path is attached",
+        severity="critical",
+        weight=11,
+        match_key="evidence",
+        match_value="none",
+        plain_language="no graph evidence path is attached; keep the review focused on user intent and source traceability.",
+        user_question="Do not force the user to trust an unsupported context.",
+        recommended_action="inspect_evidence",
+        quiet_copy="Show this as a compact signal and keep details collapsed until the user asks.",
+        report_copy="Use this signal to explain why the item belongs in the current trust queue.",
+        evidence_prompt="Compare the saved reason with source evidence before changing status.",
+        reduces_pressure=True,
+    ),
+    TrustRuleDefinition(
+        rule_id="trule_041_evidence_single",
+        dimension="evidence",
+        title="one graph evidence path is attached",
+        severity="high",
+        weight=12,
+        match_key="evidence",
+        match_value="single",
+        plain_language="one graph evidence path is attached; keep the review focused on user intent and source traceability.",
+        user_question="Check whether the one path is direct enough.",
+        recommended_action="inspect_path",
+        quiet_copy="Show this as a compact signal and keep details collapsed until the user asks.",
+        report_copy="Use this signal to explain why the item belongs in the current trust queue.",
+        evidence_prompt="Compare the saved reason with source evidence before changing status.",
+        reduces_pressure=True,
+    ),
+    TrustRuleDefinition(
+        rule_id="trule_042_evidence_multiple",
+        dimension="evidence",
+        title="multiple graph evidence paths are attached",
+        severity="medium",
+        weight=13,
+        match_key="evidence",
+        match_value="multiple",
+        plain_language="multiple graph evidence paths are attached; keep the review focused on user intent and source traceability.",
+        user_question="Compress the paths so the user sees the decision, not the graph noise.",
+        recommended_action="compress_paths",
+        quiet_copy="Show this as a compact signal and keep details collapsed until the user asks.",
+        report_copy="Use this signal to explain why the item belongs in the current trust queue.",
+        evidence_prompt="Compare the saved reason with source evidence before changing status.",
+        reduces_pressure=True,
+    ),
+    TrustRuleDefinition(
+        rule_id="trule_043_loop_none",
+        dimension="loop",
+        title="no open loop remains connected",
+        severity="low",
+        weight=14,
+        match_key="loop",
+        match_value="none",
+        plain_language="no open loop remains connected; keep the review focused on user intent and source traceability.",
+        user_question="This item can be handled as a memory quality decision.",
+        recommended_action="review_context",
+        quiet_copy="Show this as a compact signal and keep details collapsed until the user asks.",
+        report_copy="Use this signal to explain why the item belongs in the current trust queue.",
+        evidence_prompt="Compare the saved reason with source evidence before changing status.",
+        reduces_pressure=True,
+    ),
+    TrustRuleDefinition(
+        rule_id="trule_044_loop_one",
+        dimension="loop",
+        title="one open loop remains connected",
+        severity="critical",
+        weight=15,
+        match_key="loop",
+        match_value="one",
+        plain_language="one open loop remains connected; keep the review focused on user intent and source traceability.",
+        user_question="Decide whether the unresolved loop is still worth carrying.",
+        recommended_action="triage_open_loop",
+        quiet_copy="Show this as a compact signal and keep details collapsed until the user asks.",
+        report_copy="Use this signal to explain why the item belongs in the current trust queue.",
+        evidence_prompt="Compare the saved reason with source evidence before changing status.",
+        reduces_pressure=True,
+    ),
+    TrustRuleDefinition(
+        rule_id="trule_045_loop_many",
+        dimension="loop",
+        title="multiple open loops remain connected",
+        severity="high",
+        weight=16,
+        match_key="loop",
+        match_value="many",
+        plain_language="multiple open loops remain connected; keep the review focused on user intent and source traceability.",
+        user_question="Group unresolved work before asking the user to decide.",
+        recommended_action="group_open_loops",
+        quiet_copy="Show this as a compact signal and keep details collapsed until the user asks.",
+        report_copy="Use this signal to explain why the item belongs in the current trust queue.",
+        evidence_prompt="Compare the saved reason with source evidence before changing status.",
+        reduces_pressure=True,
+    ),
+    TrustRuleDefinition(
+        rule_id="trule_046_topic_none",
+        dimension="topic",
+        title="no topic currently references this source",
+        severity="low",
+        weight=17,
+        match_key="topic",
+        match_value="none",
+        plain_language="no topic currently references this source; keep the review focused on user intent and source traceability.",
+        user_question="The context may be isolated and should not dominate recall.",
+        recommended_action="inspect_topic",
+        quiet_copy="Show this as a compact signal and keep details collapsed until the user asks.",
+        report_copy="Use this signal to explain why the item belongs in the current trust queue.",
+        evidence_prompt="Compare the saved reason with source evidence before changing status.",
+        reduces_pressure=True,
+    ),
+    TrustRuleDefinition(
+        rule_id="trule_047_topic_one",
+        dimension="topic",
+        title="one topic references this source",
+        severity="critical",
+        weight=18,
+        match_key="topic",
+        match_value="one",
+        plain_language="one topic references this source; keep the review focused on user intent and source traceability.",
+        user_question="Check the source against the topic that will reuse it.",
+        recommended_action="inspect_topic",
+        quiet_copy="Show this as a compact signal and keep details collapsed until the user asks.",
+        report_copy="Use this signal to explain why the item belongs in the current trust queue.",
+        evidence_prompt="Compare the saved reason with source evidence before changing status.",
+        reduces_pressure=True,
+    ),
+    TrustRuleDefinition(
+        rule_id="trule_048_topic_many",
+        dimension="topic",
+        title="multiple topics reference this source",
+        severity="high",
+        weight=19,
+        match_key="topic",
+        match_value="many",
+        plain_language="multiple topics reference this source; keep the review focused on user intent and source traceability.",
+        user_question="Treat the source as a cross-topic trust anchor.",
+        recommended_action="inspect_bridge",
+        quiet_copy="Show this as a compact signal and keep details collapsed until the user asks.",
+        report_copy="Use this signal to explain why the item belongs in the current trust queue.",
+        evidence_prompt="Compare the saved reason with source evidence before changing status.",
+        reduces_pressure=True,
+    ),
+    TrustRuleDefinition(
+        rule_id="trule_049_history_none",
+        dimension="history",
+        title="no review history exists",
+        severity="critical",
+        weight=20,
+        match_key="history",
+        match_value="none",
+        plain_language="no review history exists; keep the review focused on user intent and source traceability.",
+        user_question="Ask for the smallest possible first decision.",
+        recommended_action="first_review",
+        quiet_copy="Show this as a compact signal and keep details collapsed until the user asks.",
+        report_copy="Use this signal to explain why the item belongs in the current trust queue.",
+        evidence_prompt="Compare the saved reason with source evidence before changing status.",
+        reduces_pressure=True,
+    ),
+    TrustRuleDefinition(
+        rule_id="trule_050_history_one",
+        dimension="history",
+        title="one review action exists",
+        severity="high",
+        weight=21,
+        match_key="history",
+        match_value="one",
+        plain_language="one review action exists; keep the review focused on user intent and source traceability.",
+        user_question="Show the last action before asking for another.",
+        recommended_action="resume_from_history",
+        quiet_copy="Show this as a compact signal and keep details collapsed until the user asks.",
+        report_copy="Use this signal to explain why the item belongs in the current trust queue.",
+        evidence_prompt="Compare the saved reason with source evidence before changing status.",
+        reduces_pressure=True,
+    ),
+    TrustRuleDefinition(
+        rule_id="trule_051_history_many",
+        dimension="history",
+        title="multiple review actions exist",
+        severity="medium",
+        weight=5,
+        match_key="history",
+        match_value="many",
+        plain_language="multiple review actions exist; keep the review focused on user intent and source traceability.",
+        user_question="Summarize the timeline to avoid decision fatigue.",
+        recommended_action="compress_history",
+        quiet_copy="Show this as a compact signal and keep details collapsed until the user asks.",
+        report_copy="Use this signal to explain why the item belongs in the current trust queue.",
+        evidence_prompt="Compare the saved reason with source evidence before changing status.",
+        reduces_pressure=True,
+    ),
+    TrustRuleDefinition(
+        rule_id="trule_052_future_none",
+        dimension="future",
+        title="no future recall question is attached",
+        severity="medium",
+        weight=6,
+        match_key="future",
+        match_value="none",
+        plain_language="no future recall question is attached; keep the review focused on user intent and source traceability.",
+        user_question="Clarify how this memory will help later.",
+        recommended_action="add_future_question",
+        quiet_copy="Show this as a compact signal and keep details collapsed until the user asks.",
+        report_copy="Use this signal to explain why the item belongs in the current trust queue.",
+        evidence_prompt="Compare the saved reason with source evidence before changing status.",
+        reduces_pressure=True,
+    ),
+    TrustRuleDefinition(
+        rule_id="trule_053_future_some",
+        dimension="future",
+        title="future recall questions are attached",
+        severity="low",
+        weight=7,
+        match_key="future",
+        match_value="some",
+        plain_language="future recall questions are attached; keep the review focused on user intent and source traceability.",
+        user_question="Use the questions to explain why review matters.",
+        recommended_action="connect_to_recall",
+        quiet_copy="Show this as a compact signal and keep details collapsed until the user asks.",
+        report_copy="Use this signal to explain why the item belongs in the current trust queue.",
+        evidence_prompt="Compare the saved reason with source evidence before changing status.",
+        reduces_pressure=True,
+    ),
+    TrustRuleDefinition(
+        rule_id="trule_054_source_map_missing",
+        dimension="source_map",
+        title="source node traceability is missing",
+        severity="critical",
+        weight=8,
+        match_key="source_map",
+        match_value="missing",
+        plain_language="source node traceability is missing; keep the review focused on user intent and source traceability.",
+        user_question="Avoid treating the memory as fully grounded.",
+        recommended_action="repair_traceability",
+        quiet_copy="Show this as a compact signal and keep details collapsed until the user asks.",
+        report_copy="Use this signal to explain why the item belongs in the current trust queue.",
+        evidence_prompt="Compare the saved reason with source evidence before changing status.",
+        reduces_pressure=True,
+    ),
+    TrustRuleDefinition(
+        rule_id="trule_055_source_map_present",
+        dimension="source_map",
+        title="source node traceability is present",
+        severity="high",
+        weight=9,
+        match_key="source_map",
+        match_value="present",
+        plain_language="source node traceability is present; keep the review focused on user intent and source traceability.",
+        user_question="Keep traceability visible but collapsed.",
+        recommended_action="preserve_traceability",
+        quiet_copy="Show this as a compact signal and keep details collapsed until the user asks.",
+        report_copy="Use this signal to explain why the item belongs in the current trust queue.",
+        evidence_prompt="Compare the saved reason with source evidence before changing status.",
+        reduces_pressure=True,
+    ),
+    TrustRuleDefinition(
+        rule_id="trule_056_boundary_AI-inferred",
+        dimension="boundary",
+        title="saved reason is AI-inferred",
+        severity="critical",
+        weight=10,
+        match_key="boundary",
+        match_value="AI-inferred",
+        plain_language="saved reason is AI-inferred; keep the review focused on user intent and source traceability.",
+        user_question="Ask whether this saved reason reflects the user, not the model.",
+        recommended_action="review_ai_inference",
+        quiet_copy="Show this as a compact signal and keep details collapsed until the user asks.",
+        report_copy="Use this signal to explain why the item belongs in the current trust queue.",
+        evidence_prompt="Compare the saved reason with source evidence before changing status.",
+        reduces_pressure=True,
+    ),
+    TrustRuleDefinition(
+        rule_id="trule_057_boundary_user-stated",
+        dimension="boundary",
+        title="saved reason was written by the user",
+        severity="high",
+        weight=11,
+        match_key="boundary",
+        match_value="user-stated",
+        plain_language="saved reason was written by the user; keep the review focused on user intent and source traceability.",
+        user_question="Protect the user-stated reason and avoid rewriting it without intent.",
+        recommended_action="preserve_user_reason",
+        quiet_copy="Show this as a compact signal and keep details collapsed until the user asks.",
+        report_copy="Use this signal to explain why the item belongs in the current trust queue.",
+        evidence_prompt="Compare the saved reason with source evidence before changing status.",
+        reduces_pressure=True,
+    ),
+    TrustRuleDefinition(
+        rule_id="trule_058_boundary_unknown",
+        dimension="boundary",
+        title="saved reason boundary is unknown",
+        severity="medium",
+        weight=12,
+        match_key="boundary",
+        match_value="unknown",
+        plain_language="saved reason boundary is unknown; keep the review focused on user intent and source traceability.",
+        user_question="Clarify whether this context came from the user or the system.",
+        recommended_action="inspect_boundary",
+        quiet_copy="Show this as a compact signal and keep details collapsed until the user asks.",
+        report_copy="Use this signal to explain why the item belongs in the current trust queue.",
+        evidence_prompt="Compare the saved reason with source evidence before changing status.",
+        reduces_pressure=True,
+    ),
+    TrustRuleDefinition(
+        rule_id="trule_059_status_unreviewed",
+        dimension="status",
+        title="review status is still unreviewed",
+        severity="high",
+        weight=13,
+        match_key="status",
+        match_value="unreviewed",
+        plain_language="review status is still unreviewed; keep the review focused on user intent and source traceability.",
+        user_question="Make a decision only after the evidence path is visible.",
+        recommended_action="review_now",
+        quiet_copy="Show this as a compact signal and keep details collapsed until the user asks.",
+        report_copy="Use this signal to explain why the item belongs in the current trust queue.",
+        evidence_prompt="Compare the saved reason with source evidence before changing status.",
+        reduces_pressure=True,
+    ),
+    TrustRuleDefinition(
+        rule_id="trule_060_status_deferred",
+        dimension="status",
+        title="previous review was deferred",
+        severity="medium",
+        weight=14,
+        match_key="status",
+        match_value="deferred",
+        plain_language="previous review was deferred; keep the review focused on user intent and source traceability.",
+        user_question="Resume the postponed decision with the smallest useful next step.",
+        recommended_action="resume_review",
+        quiet_copy="Show this as a compact signal and keep details collapsed until the user asks.",
+        report_copy="Use this signal to explain why the item belongs in the current trust queue.",
+        evidence_prompt="Compare the saved reason with source evidence before changing status.",
+        reduces_pressure=True,
+    ),
+    TrustRuleDefinition(
+        rule_id="trule_061_status_confirmed",
+        dimension="status",
+        title="this context has already been confirmed",
+        severity="low",
+        weight=15,
+        match_key="status",
+        match_value="confirmed",
+        plain_language="this context has already been confirmed; keep the review focused on user intent and source traceability.",
+        user_question="Keep it available as a trusted anchor for recall.",
+        recommended_action="monitor",
+        quiet_copy="Show this as a compact signal and keep details collapsed until the user asks.",
+        report_copy="Use this signal to explain why the item belongs in the current trust queue.",
+        evidence_prompt="Compare the saved reason with source evidence before changing status.",
+        reduces_pressure=True,
+    ),
+    TrustRuleDefinition(
+        rule_id="trule_062_status_rewritten",
+        dimension="status",
+        title="this context was rewritten by the user",
+        severity="critical",
+        weight=16,
+        match_key="status",
+        match_value="rewritten",
+        plain_language="this context was rewritten by the user; keep the review focused on user intent and source traceability.",
+        user_question="Show the rewrite as the source of truth and keep old text traceable.",
+        recommended_action="preserve_rewrite",
+        quiet_copy="Show this as a compact signal and keep details collapsed until the user asks.",
+        report_copy="Use this signal to explain why the item belongs in the current trust queue.",
+        evidence_prompt="Compare the saved reason with source evidence before changing status.",
+        reduces_pressure=True,
+    ),
+    TrustRuleDefinition(
+        rule_id="trule_063_status_rejected",
+        dimension="status",
+        title="this inference was rejected",
+        severity="high",
+        weight=17,
+        match_key="status",
+        match_value="rejected",
+        plain_language="this inference was rejected; keep the review focused on user intent and source traceability.",
+        user_question="Prevent the rejected reason from quietly returning to answers.",
+        recommended_action="inspect_rejection",
+        quiet_copy="Show this as a compact signal and keep details collapsed until the user asks.",
+        report_copy="Use this signal to explain why the item belongs in the current trust queue.",
+        evidence_prompt="Compare the saved reason with source evidence before changing status.",
+        reduces_pressure=True,
+    ),
+    TrustRuleDefinition(
+        rule_id="trule_064_confidence_very_low",
+        dimension="confidence",
+        title="confidence is below 40 percent",
+        severity="medium",
+        weight=18,
+        match_key="confidence",
+        match_value="very_low",
+        plain_language="confidence is below 40 percent; keep the review focused on user intent and source traceability.",
+        user_question="Do not let weak confidence become a stable memory.",
+        recommended_action="require_user_confirmation",
+        quiet_copy="Show this as a compact signal and keep details collapsed until the user asks.",
+        report_copy="Use this signal to explain why the item belongs in the current trust queue.",
+        evidence_prompt="Compare the saved reason with source evidence before changing status.",
+        reduces_pressure=True,
+    ),
+    TrustRuleDefinition(
+        rule_id="trule_065_confidence_low",
+        dimension="confidence",
+        title="confidence is below 55 percent",
+        severity="low",
+        weight=19,
+        match_key="confidence",
+        match_value="low",
+        plain_language="confidence is below 55 percent; keep the review focused on user intent and source traceability.",
+        user_question="Treat this as a prompt for review rather than a fact.",
+        recommended_action="require_user_confirmation",
+        quiet_copy="Show this as a compact signal and keep details collapsed until the user asks.",
+        report_copy="Use this signal to explain why the item belongs in the current trust queue.",
+        evidence_prompt="Compare the saved reason with source evidence before changing status.",
+        reduces_pressure=True,
+    ),
+    TrustRuleDefinition(
+        rule_id="trule_066_confidence_moderate",
+        dimension="confidence",
+        title="confidence is moderate",
+        severity="critical",
+        weight=20,
+        match_key="confidence",
+        match_value="moderate",
+        plain_language="confidence is moderate; keep the review focused on user intent and source traceability.",
+        user_question="Use supporting evidence before accepting the inference.",
+        recommended_action="inspect_evidence",
+        quiet_copy="Show this as a compact signal and keep details collapsed until the user asks.",
+        report_copy="Use this signal to explain why the item belongs in the current trust queue.",
+        evidence_prompt="Compare the saved reason with source evidence before changing status.",
+        reduces_pressure=True,
+    ),
+    TrustRuleDefinition(
+        rule_id="trule_067_confidence_high",
+        dimension="confidence",
+        title="confidence is high",
+        severity="high",
+        weight=21,
+        match_key="confidence",
+        match_value="high",
+        plain_language="confidence is high; keep the review focused on user intent and source traceability.",
+        user_question="A quick scan may be enough unless open loops remain.",
+        recommended_action="quick_confirm",
+        quiet_copy="Show this as a compact signal and keep details collapsed until the user asks.",
+        report_copy="Use this signal to explain why the item belongs in the current trust queue.",
+        evidence_prompt="Compare the saved reason with source evidence before changing status.",
+        reduces_pressure=True,
+    ),
+    TrustRuleDefinition(
+        rule_id="trule_068_evidence_none",
+        dimension="evidence",
+        title="no graph evidence path is attached",
+        severity="critical",
+        weight=5,
+        match_key="evidence",
+        match_value="none",
+        plain_language="no graph evidence path is attached; keep the review focused on user intent and source traceability.",
+        user_question="Do not force the user to trust an unsupported context.",
+        recommended_action="inspect_evidence",
+        quiet_copy="Show this as a compact signal and keep details collapsed until the user asks.",
+        report_copy="Use this signal to explain why the item belongs in the current trust queue.",
+        evidence_prompt="Compare the saved reason with source evidence before changing status.",
+        reduces_pressure=True,
+    ),
+    TrustRuleDefinition(
+        rule_id="trule_069_evidence_single",
+        dimension="evidence",
+        title="one graph evidence path is attached",
+        severity="high",
+        weight=6,
+        match_key="evidence",
+        match_value="single",
+        plain_language="one graph evidence path is attached; keep the review focused on user intent and source traceability.",
+        user_question="Check whether the one path is direct enough.",
+        recommended_action="inspect_path",
+        quiet_copy="Show this as a compact signal and keep details collapsed until the user asks.",
+        report_copy="Use this signal to explain why the item belongs in the current trust queue.",
+        evidence_prompt="Compare the saved reason with source evidence before changing status.",
+        reduces_pressure=True,
+    ),
+    TrustRuleDefinition(
+        rule_id="trule_070_evidence_multiple",
+        dimension="evidence",
+        title="multiple graph evidence paths are attached",
+        severity="medium",
+        weight=7,
+        match_key="evidence",
+        match_value="multiple",
+        plain_language="multiple graph evidence paths are attached; keep the review focused on user intent and source traceability.",
+        user_question="Compress the paths so the user sees the decision, not the graph noise.",
+        recommended_action="compress_paths",
+        quiet_copy="Show this as a compact signal and keep details collapsed until the user asks.",
+        report_copy="Use this signal to explain why the item belongs in the current trust queue.",
+        evidence_prompt="Compare the saved reason with source evidence before changing status.",
+        reduces_pressure=True,
+    ),
+    TrustRuleDefinition(
+        rule_id="trule_071_loop_none",
+        dimension="loop",
+        title="no open loop remains connected",
+        severity="low",
+        weight=8,
+        match_key="loop",
+        match_value="none",
+        plain_language="no open loop remains connected; keep the review focused on user intent and source traceability.",
+        user_question="This item can be handled as a memory quality decision.",
+        recommended_action="review_context",
+        quiet_copy="Show this as a compact signal and keep details collapsed until the user asks.",
+        report_copy="Use this signal to explain why the item belongs in the current trust queue.",
+        evidence_prompt="Compare the saved reason with source evidence before changing status.",
+        reduces_pressure=True,
+    ),
+    TrustRuleDefinition(
+        rule_id="trule_072_loop_one",
+        dimension="loop",
+        title="one open loop remains connected",
+        severity="critical",
+        weight=9,
+        match_key="loop",
+        match_value="one",
+        plain_language="one open loop remains connected; keep the review focused on user intent and source traceability.",
+        user_question="Decide whether the unresolved loop is still worth carrying.",
+        recommended_action="triage_open_loop",
+        quiet_copy="Show this as a compact signal and keep details collapsed until the user asks.",
+        report_copy="Use this signal to explain why the item belongs in the current trust queue.",
+        evidence_prompt="Compare the saved reason with source evidence before changing status.",
+        reduces_pressure=True,
+    ),
+    TrustRuleDefinition(
+        rule_id="trule_073_loop_many",
+        dimension="loop",
+        title="multiple open loops remain connected",
+        severity="high",
+        weight=10,
+        match_key="loop",
+        match_value="many",
+        plain_language="multiple open loops remain connected; keep the review focused on user intent and source traceability.",
+        user_question="Group unresolved work before asking the user to decide.",
+        recommended_action="group_open_loops",
+        quiet_copy="Show this as a compact signal and keep details collapsed until the user asks.",
+        report_copy="Use this signal to explain why the item belongs in the current trust queue.",
+        evidence_prompt="Compare the saved reason with source evidence before changing status.",
+        reduces_pressure=True,
+    ),
+    TrustRuleDefinition(
+        rule_id="trule_074_topic_none",
+        dimension="topic",
+        title="no topic currently references this source",
+        severity="low",
+        weight=11,
+        match_key="topic",
+        match_value="none",
+        plain_language="no topic currently references this source; keep the review focused on user intent and source traceability.",
+        user_question="The context may be isolated and should not dominate recall.",
+        recommended_action="inspect_topic",
+        quiet_copy="Show this as a compact signal and keep details collapsed until the user asks.",
+        report_copy="Use this signal to explain why the item belongs in the current trust queue.",
+        evidence_prompt="Compare the saved reason with source evidence before changing status.",
+        reduces_pressure=True,
+    ),
+    TrustRuleDefinition(
+        rule_id="trule_075_topic_one",
+        dimension="topic",
+        title="one topic references this source",
+        severity="critical",
+        weight=12,
+        match_key="topic",
+        match_value="one",
+        plain_language="one topic references this source; keep the review focused on user intent and source traceability.",
+        user_question="Check the source against the topic that will reuse it.",
+        recommended_action="inspect_topic",
+        quiet_copy="Show this as a compact signal and keep details collapsed until the user asks.",
+        report_copy="Use this signal to explain why the item belongs in the current trust queue.",
+        evidence_prompt="Compare the saved reason with source evidence before changing status.",
+        reduces_pressure=True,
+    ),
+    TrustRuleDefinition(
+        rule_id="trule_076_topic_many",
+        dimension="topic",
+        title="multiple topics reference this source",
+        severity="high",
+        weight=13,
+        match_key="topic",
+        match_value="many",
+        plain_language="multiple topics reference this source; keep the review focused on user intent and source traceability.",
+        user_question="Treat the source as a cross-topic trust anchor.",
+        recommended_action="inspect_bridge",
+        quiet_copy="Show this as a compact signal and keep details collapsed until the user asks.",
+        report_copy="Use this signal to explain why the item belongs in the current trust queue.",
+        evidence_prompt="Compare the saved reason with source evidence before changing status.",
+        reduces_pressure=True,
+    ),
+    TrustRuleDefinition(
+        rule_id="trule_077_history_none",
+        dimension="history",
+        title="no review history exists",
+        severity="critical",
+        weight=14,
+        match_key="history",
+        match_value="none",
+        plain_language="no review history exists; keep the review focused on user intent and source traceability.",
+        user_question="Ask for the smallest possible first decision.",
+        recommended_action="first_review",
+        quiet_copy="Show this as a compact signal and keep details collapsed until the user asks.",
+        report_copy="Use this signal to explain why the item belongs in the current trust queue.",
+        evidence_prompt="Compare the saved reason with source evidence before changing status.",
+        reduces_pressure=True,
+    ),
+    TrustRuleDefinition(
+        rule_id="trule_078_history_one",
+        dimension="history",
+        title="one review action exists",
+        severity="high",
+        weight=15,
+        match_key="history",
+        match_value="one",
+        plain_language="one review action exists; keep the review focused on user intent and source traceability.",
+        user_question="Show the last action before asking for another.",
+        recommended_action="resume_from_history",
+        quiet_copy="Show this as a compact signal and keep details collapsed until the user asks.",
+        report_copy="Use this signal to explain why the item belongs in the current trust queue.",
+        evidence_prompt="Compare the saved reason with source evidence before changing status.",
+        reduces_pressure=True,
+    ),
+    TrustRuleDefinition(
+        rule_id="trule_079_history_many",
+        dimension="history",
+        title="multiple review actions exist",
+        severity="medium",
+        weight=16,
+        match_key="history",
+        match_value="many",
+        plain_language="multiple review actions exist; keep the review focused on user intent and source traceability.",
+        user_question="Summarize the timeline to avoid decision fatigue.",
+        recommended_action="compress_history",
+        quiet_copy="Show this as a compact signal and keep details collapsed until the user asks.",
+        report_copy="Use this signal to explain why the item belongs in the current trust queue.",
+        evidence_prompt="Compare the saved reason with source evidence before changing status.",
+        reduces_pressure=True,
+    ),
+    TrustRuleDefinition(
+        rule_id="trule_080_future_none",
+        dimension="future",
+        title="no future recall question is attached",
+        severity="medium",
+        weight=17,
+        match_key="future",
+        match_value="none",
+        plain_language="no future recall question is attached; keep the review focused on user intent and source traceability.",
+        user_question="Clarify how this memory will help later.",
+        recommended_action="add_future_question",
+        quiet_copy="Show this as a compact signal and keep details collapsed until the user asks.",
+        report_copy="Use this signal to explain why the item belongs in the current trust queue.",
+        evidence_prompt="Compare the saved reason with source evidence before changing status.",
+        reduces_pressure=True,
+    ),
+    TrustRuleDefinition(
+        rule_id="trule_081_future_some",
+        dimension="future",
+        title="future recall questions are attached",
+        severity="low",
+        weight=18,
+        match_key="future",
+        match_value="some",
+        plain_language="future recall questions are attached; keep the review focused on user intent and source traceability.",
+        user_question="Use the questions to explain why review matters.",
+        recommended_action="connect_to_recall",
+        quiet_copy="Show this as a compact signal and keep details collapsed until the user asks.",
+        report_copy="Use this signal to explain why the item belongs in the current trust queue.",
+        evidence_prompt="Compare the saved reason with source evidence before changing status.",
+        reduces_pressure=True,
+    ),
+    TrustRuleDefinition(
+        rule_id="trule_082_source_map_missing",
+        dimension="source_map",
+        title="source node traceability is missing",
+        severity="critical",
+        weight=19,
+        match_key="source_map",
+        match_value="missing",
+        plain_language="source node traceability is missing; keep the review focused on user intent and source traceability.",
+        user_question="Avoid treating the memory as fully grounded.",
+        recommended_action="repair_traceability",
+        quiet_copy="Show this as a compact signal and keep details collapsed until the user asks.",
+        report_copy="Use this signal to explain why the item belongs in the current trust queue.",
+        evidence_prompt="Compare the saved reason with source evidence before changing status.",
+        reduces_pressure=True,
+    ),
+    TrustRuleDefinition(
+        rule_id="trule_083_source_map_present",
+        dimension="source_map",
+        title="source node traceability is present",
+        severity="high",
+        weight=20,
+        match_key="source_map",
+        match_value="present",
+        plain_language="source node traceability is present; keep the review focused on user intent and source traceability.",
+        user_question="Keep traceability visible but collapsed.",
+        recommended_action="preserve_traceability",
+        quiet_copy="Show this as a compact signal and keep details collapsed until the user asks.",
+        report_copy="Use this signal to explain why the item belongs in the current trust queue.",
+        evidence_prompt="Compare the saved reason with source evidence before changing status.",
+        reduces_pressure=True,
+    ),
+    TrustRuleDefinition(
+        rule_id="trule_084_boundary_AI-inferred",
+        dimension="boundary",
+        title="saved reason is AI-inferred",
+        severity="critical",
+        weight=21,
+        match_key="boundary",
+        match_value="AI-inferred",
+        plain_language="saved reason is AI-inferred; keep the review focused on user intent and source traceability.",
+        user_question="Ask whether this saved reason reflects the user, not the model.",
+        recommended_action="review_ai_inference",
+        quiet_copy="Show this as a compact signal and keep details collapsed until the user asks.",
+        report_copy="Use this signal to explain why the item belongs in the current trust queue.",
+        evidence_prompt="Compare the saved reason with source evidence before changing status.",
+        reduces_pressure=True,
+    ),
+    TrustRuleDefinition(
+        rule_id="trule_085_boundary_user-stated",
+        dimension="boundary",
+        title="saved reason was written by the user",
+        severity="high",
+        weight=5,
+        match_key="boundary",
+        match_value="user-stated",
+        plain_language="saved reason was written by the user; keep the review focused on user intent and source traceability.",
+        user_question="Protect the user-stated reason and avoid rewriting it without intent.",
+        recommended_action="preserve_user_reason",
+        quiet_copy="Show this as a compact signal and keep details collapsed until the user asks.",
+        report_copy="Use this signal to explain why the item belongs in the current trust queue.",
+        evidence_prompt="Compare the saved reason with source evidence before changing status.",
+        reduces_pressure=True,
+    ),
+    TrustRuleDefinition(
+        rule_id="trule_086_boundary_unknown",
+        dimension="boundary",
+        title="saved reason boundary is unknown",
+        severity="medium",
+        weight=6,
+        match_key="boundary",
+        match_value="unknown",
+        plain_language="saved reason boundary is unknown; keep the review focused on user intent and source traceability.",
+        user_question="Clarify whether this context came from the user or the system.",
+        recommended_action="inspect_boundary",
+        quiet_copy="Show this as a compact signal and keep details collapsed until the user asks.",
+        report_copy="Use this signal to explain why the item belongs in the current trust queue.",
+        evidence_prompt="Compare the saved reason with source evidence before changing status.",
+        reduces_pressure=True,
+    ),
+    TrustRuleDefinition(
+        rule_id="trule_087_status_unreviewed",
+        dimension="status",
+        title="review status is still unreviewed",
+        severity="high",
+        weight=7,
+        match_key="status",
+        match_value="unreviewed",
+        plain_language="review status is still unreviewed; keep the review focused on user intent and source traceability.",
+        user_question="Make a decision only after the evidence path is visible.",
+        recommended_action="review_now",
+        quiet_copy="Show this as a compact signal and keep details collapsed until the user asks.",
+        report_copy="Use this signal to explain why the item belongs in the current trust queue.",
+        evidence_prompt="Compare the saved reason with source evidence before changing status.",
+        reduces_pressure=True,
+    ),
+    TrustRuleDefinition(
+        rule_id="trule_088_status_deferred",
+        dimension="status",
+        title="previous review was deferred",
+        severity="medium",
+        weight=8,
+        match_key="status",
+        match_value="deferred",
+        plain_language="previous review was deferred; keep the review focused on user intent and source traceability.",
+        user_question="Resume the postponed decision with the smallest useful next step.",
+        recommended_action="resume_review",
+        quiet_copy="Show this as a compact signal and keep details collapsed until the user asks.",
+        report_copy="Use this signal to explain why the item belongs in the current trust queue.",
+        evidence_prompt="Compare the saved reason with source evidence before changing status.",
+        reduces_pressure=True,
+    ),
+    TrustRuleDefinition(
+        rule_id="trule_089_status_confirmed",
+        dimension="status",
+        title="this context has already been confirmed",
+        severity="low",
+        weight=9,
+        match_key="status",
+        match_value="confirmed",
+        plain_language="this context has already been confirmed; keep the review focused on user intent and source traceability.",
+        user_question="Keep it available as a trusted anchor for recall.",
+        recommended_action="monitor",
+        quiet_copy="Show this as a compact signal and keep details collapsed until the user asks.",
+        report_copy="Use this signal to explain why the item belongs in the current trust queue.",
+        evidence_prompt="Compare the saved reason with source evidence before changing status.",
+        reduces_pressure=True,
+    ),
+    TrustRuleDefinition(
+        rule_id="trule_090_status_rewritten",
+        dimension="status",
+        title="this context was rewritten by the user",
+        severity="critical",
+        weight=10,
+        match_key="status",
+        match_value="rewritten",
+        plain_language="this context was rewritten by the user; keep the review focused on user intent and source traceability.",
+        user_question="Show the rewrite as the source of truth and keep old text traceable.",
+        recommended_action="preserve_rewrite",
+        quiet_copy="Show this as a compact signal and keep details collapsed until the user asks.",
+        report_copy="Use this signal to explain why the item belongs in the current trust queue.",
+        evidence_prompt="Compare the saved reason with source evidence before changing status.",
+        reduces_pressure=True,
+    ),
+    TrustRuleDefinition(
+        rule_id="trule_091_status_rejected",
+        dimension="status",
+        title="this inference was rejected",
+        severity="high",
+        weight=11,
+        match_key="status",
+        match_value="rejected",
+        plain_language="this inference was rejected; keep the review focused on user intent and source traceability.",
+        user_question="Prevent the rejected reason from quietly returning to answers.",
+        recommended_action="inspect_rejection",
+        quiet_copy="Show this as a compact signal and keep details collapsed until the user asks.",
+        report_copy="Use this signal to explain why the item belongs in the current trust queue.",
+        evidence_prompt="Compare the saved reason with source evidence before changing status.",
+        reduces_pressure=True,
+    ),
+    TrustRuleDefinition(
+        rule_id="trule_092_confidence_very_low",
+        dimension="confidence",
+        title="confidence is below 40 percent",
+        severity="medium",
+        weight=12,
+        match_key="confidence",
+        match_value="very_low",
+        plain_language="confidence is below 40 percent; keep the review focused on user intent and source traceability.",
+        user_question="Do not let weak confidence become a stable memory.",
+        recommended_action="require_user_confirmation",
+        quiet_copy="Show this as a compact signal and keep details collapsed until the user asks.",
+        report_copy="Use this signal to explain why the item belongs in the current trust queue.",
+        evidence_prompt="Compare the saved reason with source evidence before changing status.",
+        reduces_pressure=True,
+    ),
+    TrustRuleDefinition(
+        rule_id="trule_093_confidence_low",
+        dimension="confidence",
+        title="confidence is below 55 percent",
+        severity="low",
+        weight=13,
+        match_key="confidence",
+        match_value="low",
+        plain_language="confidence is below 55 percent; keep the review focused on user intent and source traceability.",
+        user_question="Treat this as a prompt for review rather than a fact.",
+        recommended_action="require_user_confirmation",
+        quiet_copy="Show this as a compact signal and keep details collapsed until the user asks.",
+        report_copy="Use this signal to explain why the item belongs in the current trust queue.",
+        evidence_prompt="Compare the saved reason with source evidence before changing status.",
+        reduces_pressure=True,
+    ),
+    TrustRuleDefinition(
+        rule_id="trule_094_confidence_moderate",
+        dimension="confidence",
+        title="confidence is moderate",
+        severity="critical",
+        weight=14,
+        match_key="confidence",
+        match_value="moderate",
+        plain_language="confidence is moderate; keep the review focused on user intent and source traceability.",
+        user_question="Use supporting evidence before accepting the inference.",
+        recommended_action="inspect_evidence",
+        quiet_copy="Show this as a compact signal and keep details collapsed until the user asks.",
+        report_copy="Use this signal to explain why the item belongs in the current trust queue.",
+        evidence_prompt="Compare the saved reason with source evidence before changing status.",
+        reduces_pressure=True,
+    ),
+    TrustRuleDefinition(
+        rule_id="trule_095_confidence_high",
+        dimension="confidence",
+        title="confidence is high",
+        severity="high",
+        weight=15,
+        match_key="confidence",
+        match_value="high",
+        plain_language="confidence is high; keep the review focused on user intent and source traceability.",
+        user_question="A quick scan may be enough unless open loops remain.",
+        recommended_action="quick_confirm",
+        quiet_copy="Show this as a compact signal and keep details collapsed until the user asks.",
+        report_copy="Use this signal to explain why the item belongs in the current trust queue.",
+        evidence_prompt="Compare the saved reason with source evidence before changing status.",
+        reduces_pressure=True,
+    ),
+    TrustRuleDefinition(
+        rule_id="trule_096_evidence_none",
+        dimension="evidence",
+        title="no graph evidence path is attached",
+        severity="critical",
+        weight=16,
+        match_key="evidence",
+        match_value="none",
+        plain_language="no graph evidence path is attached; keep the review focused on user intent and source traceability.",
+        user_question="Do not force the user to trust an unsupported context.",
+        recommended_action="inspect_evidence",
+        quiet_copy="Show this as a compact signal and keep details collapsed until the user asks.",
+        report_copy="Use this signal to explain why the item belongs in the current trust queue.",
+        evidence_prompt="Compare the saved reason with source evidence before changing status.",
+        reduces_pressure=True,
+    ),
+    TrustRuleDefinition(
+        rule_id="trule_097_evidence_single",
+        dimension="evidence",
+        title="one graph evidence path is attached",
+        severity="high",
+        weight=17,
+        match_key="evidence",
+        match_value="single",
+        plain_language="one graph evidence path is attached; keep the review focused on user intent and source traceability.",
+        user_question="Check whether the one path is direct enough.",
+        recommended_action="inspect_path",
+        quiet_copy="Show this as a compact signal and keep details collapsed until the user asks.",
+        report_copy="Use this signal to explain why the item belongs in the current trust queue.",
+        evidence_prompt="Compare the saved reason with source evidence before changing status.",
+        reduces_pressure=True,
+    ),
+    TrustRuleDefinition(
+        rule_id="trule_098_evidence_multiple",
+        dimension="evidence",
+        title="multiple graph evidence paths are attached",
+        severity="medium",
+        weight=18,
+        match_key="evidence",
+        match_value="multiple",
+        plain_language="multiple graph evidence paths are attached; keep the review focused on user intent and source traceability.",
+        user_question="Compress the paths so the user sees the decision, not the graph noise.",
+        recommended_action="compress_paths",
+        quiet_copy="Show this as a compact signal and keep details collapsed until the user asks.",
+        report_copy="Use this signal to explain why the item belongs in the current trust queue.",
+        evidence_prompt="Compare the saved reason with source evidence before changing status.",
+        reduces_pressure=True,
+    ),
+    TrustRuleDefinition(
+        rule_id="trule_099_loop_none",
+        dimension="loop",
+        title="no open loop remains connected",
+        severity="low",
+        weight=19,
+        match_key="loop",
+        match_value="none",
+        plain_language="no open loop remains connected; keep the review focused on user intent and source traceability.",
+        user_question="This item can be handled as a memory quality decision.",
+        recommended_action="review_context",
+        quiet_copy="Show this as a compact signal and keep details collapsed until the user asks.",
+        report_copy="Use this signal to explain why the item belongs in the current trust queue.",
+        evidence_prompt="Compare the saved reason with source evidence before changing status.",
+        reduces_pressure=True,
+    ),
+    TrustRuleDefinition(
+        rule_id="trule_100_loop_one",
+        dimension="loop",
+        title="one open loop remains connected",
+        severity="critical",
+        weight=20,
+        match_key="loop",
+        match_value="one",
+        plain_language="one open loop remains connected; keep the review focused on user intent and source traceability.",
+        user_question="Decide whether the unresolved loop is still worth carrying.",
+        recommended_action="triage_open_loop",
+        quiet_copy="Show this as a compact signal and keep details collapsed until the user asks.",
+        report_copy="Use this signal to explain why the item belongs in the current trust queue.",
+        evidence_prompt="Compare the saved reason with source evidence before changing status.",
+        reduces_pressure=True,
+    ),
+    TrustRuleDefinition(
+        rule_id="trule_101_loop_many",
+        dimension="loop",
+        title="multiple open loops remain connected",
+        severity="high",
+        weight=21,
+        match_key="loop",
+        match_value="many",
+        plain_language="multiple open loops remain connected; keep the review focused on user intent and source traceability.",
+        user_question="Group unresolved work before asking the user to decide.",
+        recommended_action="group_open_loops",
+        quiet_copy="Show this as a compact signal and keep details collapsed until the user asks.",
+        report_copy="Use this signal to explain why the item belongs in the current trust queue.",
+        evidence_prompt="Compare the saved reason with source evidence before changing status.",
+        reduces_pressure=True,
+    ),
+    TrustRuleDefinition(
+        rule_id="trule_102_topic_none",
+        dimension="topic",
+        title="no topic currently references this source",
+        severity="low",
+        weight=5,
+        match_key="topic",
+        match_value="none",
+        plain_language="no topic currently references this source; keep the review focused on user intent and source traceability.",
+        user_question="The context may be isolated and should not dominate recall.",
+        recommended_action="inspect_topic",
+        quiet_copy="Show this as a compact signal and keep details collapsed until the user asks.",
+        report_copy="Use this signal to explain why the item belongs in the current trust queue.",
+        evidence_prompt="Compare the saved reason with source evidence before changing status.",
+        reduces_pressure=True,
+    ),
+    TrustRuleDefinition(
+        rule_id="trule_103_topic_one",
+        dimension="topic",
+        title="one topic references this source",
+        severity="critical",
+        weight=6,
+        match_key="topic",
+        match_value="one",
+        plain_language="one topic references this source; keep the review focused on user intent and source traceability.",
+        user_question="Check the source against the topic that will reuse it.",
+        recommended_action="inspect_topic",
+        quiet_copy="Show this as a compact signal and keep details collapsed until the user asks.",
+        report_copy="Use this signal to explain why the item belongs in the current trust queue.",
+        evidence_prompt="Compare the saved reason with source evidence before changing status.",
+        reduces_pressure=True,
+    ),
+    TrustRuleDefinition(
+        rule_id="trule_104_topic_many",
+        dimension="topic",
+        title="multiple topics reference this source",
+        severity="high",
+        weight=7,
+        match_key="topic",
+        match_value="many",
+        plain_language="multiple topics reference this source; keep the review focused on user intent and source traceability.",
+        user_question="Treat the source as a cross-topic trust anchor.",
+        recommended_action="inspect_bridge",
+        quiet_copy="Show this as a compact signal and keep details collapsed until the user asks.",
+        report_copy="Use this signal to explain why the item belongs in the current trust queue.",
+        evidence_prompt="Compare the saved reason with source evidence before changing status.",
+        reduces_pressure=True,
+    ),
+    TrustRuleDefinition(
+        rule_id="trule_105_history_none",
+        dimension="history",
+        title="no review history exists",
+        severity="critical",
+        weight=8,
+        match_key="history",
+        match_value="none",
+        plain_language="no review history exists; keep the review focused on user intent and source traceability.",
+        user_question="Ask for the smallest possible first decision.",
+        recommended_action="first_review",
+        quiet_copy="Show this as a compact signal and keep details collapsed until the user asks.",
+        report_copy="Use this signal to explain why the item belongs in the current trust queue.",
+        evidence_prompt="Compare the saved reason with source evidence before changing status.",
+        reduces_pressure=True,
+    ),
+    TrustRuleDefinition(
+        rule_id="trule_106_history_one",
+        dimension="history",
+        title="one review action exists",
+        severity="high",
+        weight=9,
+        match_key="history",
+        match_value="one",
+        plain_language="one review action exists; keep the review focused on user intent and source traceability.",
+        user_question="Show the last action before asking for another.",
+        recommended_action="resume_from_history",
+        quiet_copy="Show this as a compact signal and keep details collapsed until the user asks.",
+        report_copy="Use this signal to explain why the item belongs in the current trust queue.",
+        evidence_prompt="Compare the saved reason with source evidence before changing status.",
+        reduces_pressure=True,
+    ),
+    TrustRuleDefinition(
+        rule_id="trule_107_history_many",
+        dimension="history",
+        title="multiple review actions exist",
+        severity="medium",
+        weight=10,
+        match_key="history",
+        match_value="many",
+        plain_language="multiple review actions exist; keep the review focused on user intent and source traceability.",
+        user_question="Summarize the timeline to avoid decision fatigue.",
+        recommended_action="compress_history",
+        quiet_copy="Show this as a compact signal and keep details collapsed until the user asks.",
+        report_copy="Use this signal to explain why the item belongs in the current trust queue.",
+        evidence_prompt="Compare the saved reason with source evidence before changing status.",
+        reduces_pressure=True,
+    ),
+    TrustRuleDefinition(
+        rule_id="trule_108_future_none",
+        dimension="future",
+        title="no future recall question is attached",
+        severity="medium",
+        weight=11,
+        match_key="future",
+        match_value="none",
+        plain_language="no future recall question is attached; keep the review focused on user intent and source traceability.",
+        user_question="Clarify how this memory will help later.",
+        recommended_action="add_future_question",
+        quiet_copy="Show this as a compact signal and keep details collapsed until the user asks.",
+        report_copy="Use this signal to explain why the item belongs in the current trust queue.",
+        evidence_prompt="Compare the saved reason with source evidence before changing status.",
+        reduces_pressure=True,
+    ),
+    TrustRuleDefinition(
+        rule_id="trule_109_future_some",
+        dimension="future",
+        title="future recall questions are attached",
+        severity="low",
+        weight=12,
+        match_key="future",
+        match_value="some",
+        plain_language="future recall questions are attached; keep the review focused on user intent and source traceability.",
+        user_question="Use the questions to explain why review matters.",
+        recommended_action="connect_to_recall",
+        quiet_copy="Show this as a compact signal and keep details collapsed until the user asks.",
+        report_copy="Use this signal to explain why the item belongs in the current trust queue.",
+        evidence_prompt="Compare the saved reason with source evidence before changing status.",
+        reduces_pressure=True,
+    ),
+    TrustRuleDefinition(
+        rule_id="trule_110_source_map_missing",
+        dimension="source_map",
+        title="source node traceability is missing",
+        severity="critical",
+        weight=13,
+        match_key="source_map",
+        match_value="missing",
+        plain_language="source node traceability is missing; keep the review focused on user intent and source traceability.",
+        user_question="Avoid treating the memory as fully grounded.",
+        recommended_action="repair_traceability",
+        quiet_copy="Show this as a compact signal and keep details collapsed until the user asks.",
+        report_copy="Use this signal to explain why the item belongs in the current trust queue.",
+        evidence_prompt="Compare the saved reason with source evidence before changing status.",
+        reduces_pressure=True,
+    ),
+    TrustRuleDefinition(
+        rule_id="trule_111_source_map_present",
+        dimension="source_map",
+        title="source node traceability is present",
+        severity="high",
+        weight=14,
+        match_key="source_map",
+        match_value="present",
+        plain_language="source node traceability is present; keep the review focused on user intent and source traceability.",
+        user_question="Keep traceability visible but collapsed.",
+        recommended_action="preserve_traceability",
+        quiet_copy="Show this as a compact signal and keep details collapsed until the user asks.",
+        report_copy="Use this signal to explain why the item belongs in the current trust queue.",
+        evidence_prompt="Compare the saved reason with source evidence before changing status.",
+        reduces_pressure=True,
+    ),
+    TrustRuleDefinition(
+        rule_id="trule_112_boundary_AI-inferred",
+        dimension="boundary",
+        title="saved reason is AI-inferred",
+        severity="critical",
+        weight=15,
+        match_key="boundary",
+        match_value="AI-inferred",
+        plain_language="saved reason is AI-inferred; keep the review focused on user intent and source traceability.",
+        user_question="Ask whether this saved reason reflects the user, not the model.",
+        recommended_action="review_ai_inference",
+        quiet_copy="Show this as a compact signal and keep details collapsed until the user asks.",
+        report_copy="Use this signal to explain why the item belongs in the current trust queue.",
+        evidence_prompt="Compare the saved reason with source evidence before changing status.",
+        reduces_pressure=True,
+    ),
+    TrustRuleDefinition(
+        rule_id="trule_113_boundary_user-stated",
+        dimension="boundary",
+        title="saved reason was written by the user",
+        severity="high",
+        weight=16,
+        match_key="boundary",
+        match_value="user-stated",
+        plain_language="saved reason was written by the user; keep the review focused on user intent and source traceability.",
+        user_question="Protect the user-stated reason and avoid rewriting it without intent.",
+        recommended_action="preserve_user_reason",
+        quiet_copy="Show this as a compact signal and keep details collapsed until the user asks.",
+        report_copy="Use this signal to explain why the item belongs in the current trust queue.",
+        evidence_prompt="Compare the saved reason with source evidence before changing status.",
+        reduces_pressure=True,
+    ),
+    TrustRuleDefinition(
+        rule_id="trule_114_boundary_unknown",
+        dimension="boundary",
+        title="saved reason boundary is unknown",
+        severity="medium",
+        weight=17,
+        match_key="boundary",
+        match_value="unknown",
+        plain_language="saved reason boundary is unknown; keep the review focused on user intent and source traceability.",
+        user_question="Clarify whether this context came from the user or the system.",
+        recommended_action="inspect_boundary",
+        quiet_copy="Show this as a compact signal and keep details collapsed until the user asks.",
+        report_copy="Use this signal to explain why the item belongs in the current trust queue.",
+        evidence_prompt="Compare the saved reason with source evidence before changing status.",
+        reduces_pressure=True,
+    ),
+    TrustRuleDefinition(
+        rule_id="trule_115_status_unreviewed",
+        dimension="status",
+        title="review status is still unreviewed",
+        severity="high",
+        weight=18,
+        match_key="status",
+        match_value="unreviewed",
+        plain_language="review status is still unreviewed; keep the review focused on user intent and source traceability.",
+        user_question="Make a decision only after the evidence path is visible.",
+        recommended_action="review_now",
+        quiet_copy="Show this as a compact signal and keep details collapsed until the user asks.",
+        report_copy="Use this signal to explain why the item belongs in the current trust queue.",
+        evidence_prompt="Compare the saved reason with source evidence before changing status.",
+        reduces_pressure=True,
+    ),
+    TrustRuleDefinition(
+        rule_id="trule_116_status_deferred",
+        dimension="status",
+        title="previous review was deferred",
+        severity="medium",
+        weight=19,
+        match_key="status",
+        match_value="deferred",
+        plain_language="previous review was deferred; keep the review focused on user intent and source traceability.",
+        user_question="Resume the postponed decision with the smallest useful next step.",
+        recommended_action="resume_review",
+        quiet_copy="Show this as a compact signal and keep details collapsed until the user asks.",
+        report_copy="Use this signal to explain why the item belongs in the current trust queue.",
+        evidence_prompt="Compare the saved reason with source evidence before changing status.",
+        reduces_pressure=True,
+    ),
+    TrustRuleDefinition(
+        rule_id="trule_117_status_confirmed",
+        dimension="status",
+        title="this context has already been confirmed",
+        severity="low",
+        weight=20,
+        match_key="status",
+        match_value="confirmed",
+        plain_language="this context has already been confirmed; keep the review focused on user intent and source traceability.",
+        user_question="Keep it available as a trusted anchor for recall.",
+        recommended_action="monitor",
+        quiet_copy="Show this as a compact signal and keep details collapsed until the user asks.",
+        report_copy="Use this signal to explain why the item belongs in the current trust queue.",
+        evidence_prompt="Compare the saved reason with source evidence before changing status.",
+        reduces_pressure=True,
+    ),
+    TrustRuleDefinition(
+        rule_id="trule_118_status_rewritten",
+        dimension="status",
+        title="this context was rewritten by the user",
+        severity="critical",
+        weight=21,
+        match_key="status",
+        match_value="rewritten",
+        plain_language="this context was rewritten by the user; keep the review focused on user intent and source traceability.",
+        user_question="Show the rewrite as the source of truth and keep old text traceable.",
+        recommended_action="preserve_rewrite",
+        quiet_copy="Show this as a compact signal and keep details collapsed until the user asks.",
+        report_copy="Use this signal to explain why the item belongs in the current trust queue.",
+        evidence_prompt="Compare the saved reason with source evidence before changing status.",
+        reduces_pressure=True,
+    ),
+    TrustRuleDefinition(
+        rule_id="trule_119_status_rejected",
+        dimension="status",
+        title="this inference was rejected",
+        severity="high",
+        weight=5,
+        match_key="status",
+        match_value="rejected",
+        plain_language="this inference was rejected; keep the review focused on user intent and source traceability.",
+        user_question="Prevent the rejected reason from quietly returning to answers.",
+        recommended_action="inspect_rejection",
+        quiet_copy="Show this as a compact signal and keep details collapsed until the user asks.",
+        report_copy="Use this signal to explain why the item belongs in the current trust queue.",
+        evidence_prompt="Compare the saved reason with source evidence before changing status.",
+        reduces_pressure=True,
+    ),
+    TrustRuleDefinition(
+        rule_id="trule_120_confidence_very_low",
+        dimension="confidence",
+        title="confidence is below 40 percent",
+        severity="medium",
+        weight=6,
+        match_key="confidence",
+        match_value="very_low",
+        plain_language="confidence is below 40 percent; keep the review focused on user intent and source traceability.",
+        user_question="Do not let weak confidence become a stable memory.",
+        recommended_action="require_user_confirmation",
+        quiet_copy="Show this as a compact signal and keep details collapsed until the user asks.",
+        report_copy="Use this signal to explain why the item belongs in the current trust queue.",
+        evidence_prompt="Compare the saved reason with source evidence before changing status.",
+        reduces_pressure=True,
+    ),
+    TrustRuleDefinition(
+        rule_id="trule_121_confidence_low",
+        dimension="confidence",
+        title="confidence is below 55 percent",
+        severity="low",
+        weight=7,
+        match_key="confidence",
+        match_value="low",
+        plain_language="confidence is below 55 percent; keep the review focused on user intent and source traceability.",
+        user_question="Treat this as a prompt for review rather than a fact.",
+        recommended_action="require_user_confirmation",
+        quiet_copy="Show this as a compact signal and keep details collapsed until the user asks.",
+        report_copy="Use this signal to explain why the item belongs in the current trust queue.",
+        evidence_prompt="Compare the saved reason with source evidence before changing status.",
+        reduces_pressure=True,
+    ),
+    TrustRuleDefinition(
+        rule_id="trule_122_confidence_moderate",
+        dimension="confidence",
+        title="confidence is moderate",
+        severity="critical",
+        weight=8,
+        match_key="confidence",
+        match_value="moderate",
+        plain_language="confidence is moderate; keep the review focused on user intent and source traceability.",
+        user_question="Use supporting evidence before accepting the inference.",
+        recommended_action="inspect_evidence",
+        quiet_copy="Show this as a compact signal and keep details collapsed until the user asks.",
+        report_copy="Use this signal to explain why the item belongs in the current trust queue.",
+        evidence_prompt="Compare the saved reason with source evidence before changing status.",
+        reduces_pressure=True,
+    ),
+    TrustRuleDefinition(
+        rule_id="trule_123_confidence_high",
+        dimension="confidence",
+        title="confidence is high",
+        severity="high",
+        weight=9,
+        match_key="confidence",
+        match_value="high",
+        plain_language="confidence is high; keep the review focused on user intent and source traceability.",
+        user_question="A quick scan may be enough unless open loops remain.",
+        recommended_action="quick_confirm",
+        quiet_copy="Show this as a compact signal and keep details collapsed until the user asks.",
+        report_copy="Use this signal to explain why the item belongs in the current trust queue.",
+        evidence_prompt="Compare the saved reason with source evidence before changing status.",
+        reduces_pressure=True,
+    ),
+    TrustRuleDefinition(
+        rule_id="trule_124_evidence_none",
+        dimension="evidence",
+        title="no graph evidence path is attached",
+        severity="critical",
+        weight=10,
+        match_key="evidence",
+        match_value="none",
+        plain_language="no graph evidence path is attached; keep the review focused on user intent and source traceability.",
+        user_question="Do not force the user to trust an unsupported context.",
+        recommended_action="inspect_evidence",
+        quiet_copy="Show this as a compact signal and keep details collapsed until the user asks.",
+        report_copy="Use this signal to explain why the item belongs in the current trust queue.",
+        evidence_prompt="Compare the saved reason with source evidence before changing status.",
+        reduces_pressure=True,
+    ),
+    TrustRuleDefinition(
+        rule_id="trule_125_evidence_single",
+        dimension="evidence",
+        title="one graph evidence path is attached",
+        severity="high",
+        weight=11,
+        match_key="evidence",
+        match_value="single",
+        plain_language="one graph evidence path is attached; keep the review focused on user intent and source traceability.",
+        user_question="Check whether the one path is direct enough.",
+        recommended_action="inspect_path",
+        quiet_copy="Show this as a compact signal and keep details collapsed until the user asks.",
+        report_copy="Use this signal to explain why the item belongs in the current trust queue.",
+        evidence_prompt="Compare the saved reason with source evidence before changing status.",
+        reduces_pressure=True,
+    ),
+    TrustRuleDefinition(
+        rule_id="trule_126_evidence_multiple",
+        dimension="evidence",
+        title="multiple graph evidence paths are attached",
+        severity="medium",
+        weight=12,
+        match_key="evidence",
+        match_value="multiple",
+        plain_language="multiple graph evidence paths are attached; keep the review focused on user intent and source traceability.",
+        user_question="Compress the paths so the user sees the decision, not the graph noise.",
+        recommended_action="compress_paths",
+        quiet_copy="Show this as a compact signal and keep details collapsed until the user asks.",
+        report_copy="Use this signal to explain why the item belongs in the current trust queue.",
+        evidence_prompt="Compare the saved reason with source evidence before changing status.",
+        reduces_pressure=True,
+    ),
+    TrustRuleDefinition(
+        rule_id="trule_127_loop_none",
+        dimension="loop",
+        title="no open loop remains connected",
+        severity="low",
+        weight=13,
+        match_key="loop",
+        match_value="none",
+        plain_language="no open loop remains connected; keep the review focused on user intent and source traceability.",
+        user_question="This item can be handled as a memory quality decision.",
+        recommended_action="review_context",
+        quiet_copy="Show this as a compact signal and keep details collapsed until the user asks.",
+        report_copy="Use this signal to explain why the item belongs in the current trust queue.",
+        evidence_prompt="Compare the saved reason with source evidence before changing status.",
+        reduces_pressure=True,
+    ),
+    TrustRuleDefinition(
+        rule_id="trule_128_loop_one",
+        dimension="loop",
+        title="one open loop remains connected",
+        severity="critical",
+        weight=14,
+        match_key="loop",
+        match_value="one",
+        plain_language="one open loop remains connected; keep the review focused on user intent and source traceability.",
+        user_question="Decide whether the unresolved loop is still worth carrying.",
+        recommended_action="triage_open_loop",
+        quiet_copy="Show this as a compact signal and keep details collapsed until the user asks.",
+        report_copy="Use this signal to explain why the item belongs in the current trust queue.",
+        evidence_prompt="Compare the saved reason with source evidence before changing status.",
+        reduces_pressure=True,
+    ),
+    TrustRuleDefinition(
+        rule_id="trule_129_loop_many",
+        dimension="loop",
+        title="multiple open loops remain connected",
+        severity="high",
+        weight=15,
+        match_key="loop",
+        match_value="many",
+        plain_language="multiple open loops remain connected; keep the review focused on user intent and source traceability.",
+        user_question="Group unresolved work before asking the user to decide.",
+        recommended_action="group_open_loops",
+        quiet_copy="Show this as a compact signal and keep details collapsed until the user asks.",
+        report_copy="Use this signal to explain why the item belongs in the current trust queue.",
+        evidence_prompt="Compare the saved reason with source evidence before changing status.",
+        reduces_pressure=True,
+    ),
+    TrustRuleDefinition(
+        rule_id="trule_130_topic_none",
+        dimension="topic",
+        title="no topic currently references this source",
+        severity="low",
+        weight=16,
+        match_key="topic",
+        match_value="none",
+        plain_language="no topic currently references this source; keep the review focused on user intent and source traceability.",
+        user_question="The context may be isolated and should not dominate recall.",
+        recommended_action="inspect_topic",
+        quiet_copy="Show this as a compact signal and keep details collapsed until the user asks.",
+        report_copy="Use this signal to explain why the item belongs in the current trust queue.",
+        evidence_prompt="Compare the saved reason with source evidence before changing status.",
+        reduces_pressure=True,
+    ),
+    TrustRuleDefinition(
+        rule_id="trule_131_topic_one",
+        dimension="topic",
+        title="one topic references this source",
+        severity="critical",
+        weight=17,
+        match_key="topic",
+        match_value="one",
+        plain_language="one topic references this source; keep the review focused on user intent and source traceability.",
+        user_question="Check the source against the topic that will reuse it.",
+        recommended_action="inspect_topic",
+        quiet_copy="Show this as a compact signal and keep details collapsed until the user asks.",
+        report_copy="Use this signal to explain why the item belongs in the current trust queue.",
+        evidence_prompt="Compare the saved reason with source evidence before changing status.",
+        reduces_pressure=True,
+    ),
+    TrustRuleDefinition(
+        rule_id="trule_132_topic_many",
+        dimension="topic",
+        title="multiple topics reference this source",
+        severity="high",
+        weight=18,
+        match_key="topic",
+        match_value="many",
+        plain_language="multiple topics reference this source; keep the review focused on user intent and source traceability.",
+        user_question="Treat the source as a cross-topic trust anchor.",
+        recommended_action="inspect_bridge",
+        quiet_copy="Show this as a compact signal and keep details collapsed until the user asks.",
+        report_copy="Use this signal to explain why the item belongs in the current trust queue.",
+        evidence_prompt="Compare the saved reason with source evidence before changing status.",
+        reduces_pressure=True,
+    ),
+    TrustRuleDefinition(
+        rule_id="trule_133_history_none",
+        dimension="history",
+        title="no review history exists",
+        severity="critical",
+        weight=19,
+        match_key="history",
+        match_value="none",
+        plain_language="no review history exists; keep the review focused on user intent and source traceability.",
+        user_question="Ask for the smallest possible first decision.",
+        recommended_action="first_review",
+        quiet_copy="Show this as a compact signal and keep details collapsed until the user asks.",
+        report_copy="Use this signal to explain why the item belongs in the current trust queue.",
+        evidence_prompt="Compare the saved reason with source evidence before changing status.",
+        reduces_pressure=True,
+    ),
+    TrustRuleDefinition(
+        rule_id="trule_134_history_one",
+        dimension="history",
+        title="one review action exists",
+        severity="high",
+        weight=20,
+        match_key="history",
+        match_value="one",
+        plain_language="one review action exists; keep the review focused on user intent and source traceability.",
+        user_question="Show the last action before asking for another.",
+        recommended_action="resume_from_history",
+        quiet_copy="Show this as a compact signal and keep details collapsed until the user asks.",
+        report_copy="Use this signal to explain why the item belongs in the current trust queue.",
+        evidence_prompt="Compare the saved reason with source evidence before changing status.",
+        reduces_pressure=True,
+    ),
+    TrustRuleDefinition(
+        rule_id="trule_135_history_many",
+        dimension="history",
+        title="multiple review actions exist",
+        severity="medium",
+        weight=21,
+        match_key="history",
+        match_value="many",
+        plain_language="multiple review actions exist; keep the review focused on user intent and source traceability.",
+        user_question="Summarize the timeline to avoid decision fatigue.",
+        recommended_action="compress_history",
+        quiet_copy="Show this as a compact signal and keep details collapsed until the user asks.",
+        report_copy="Use this signal to explain why the item belongs in the current trust queue.",
+        evidence_prompt="Compare the saved reason with source evidence before changing status.",
+        reduces_pressure=True,
+    ),
+    TrustRuleDefinition(
+        rule_id="trule_136_future_none",
+        dimension="future",
+        title="no future recall question is attached",
+        severity="medium",
+        weight=5,
+        match_key="future",
+        match_value="none",
+        plain_language="no future recall question is attached; keep the review focused on user intent and source traceability.",
+        user_question="Clarify how this memory will help later.",
+        recommended_action="add_future_question",
+        quiet_copy="Show this as a compact signal and keep details collapsed until the user asks.",
+        report_copy="Use this signal to explain why the item belongs in the current trust queue.",
+        evidence_prompt="Compare the saved reason with source evidence before changing status.",
+        reduces_pressure=True,
+    ),
+    TrustRuleDefinition(
+        rule_id="trule_137_future_some",
+        dimension="future",
+        title="future recall questions are attached",
+        severity="low",
+        weight=6,
+        match_key="future",
+        match_value="some",
+        plain_language="future recall questions are attached; keep the review focused on user intent and source traceability.",
+        user_question="Use the questions to explain why review matters.",
+        recommended_action="connect_to_recall",
+        quiet_copy="Show this as a compact signal and keep details collapsed until the user asks.",
+        report_copy="Use this signal to explain why the item belongs in the current trust queue.",
+        evidence_prompt="Compare the saved reason with source evidence before changing status.",
+        reduces_pressure=True,
+    ),
+    TrustRuleDefinition(
+        rule_id="trule_138_source_map_missing",
+        dimension="source_map",
+        title="source node traceability is missing",
+        severity="critical",
+        weight=7,
+        match_key="source_map",
+        match_value="missing",
+        plain_language="source node traceability is missing; keep the review focused on user intent and source traceability.",
+        user_question="Avoid treating the memory as fully grounded.",
+        recommended_action="repair_traceability",
+        quiet_copy="Show this as a compact signal and keep details collapsed until the user asks.",
+        report_copy="Use this signal to explain why the item belongs in the current trust queue.",
+        evidence_prompt="Compare the saved reason with source evidence before changing status.",
+        reduces_pressure=True,
+    ),
+    TrustRuleDefinition(
+        rule_id="trule_139_source_map_present",
+        dimension="source_map",
+        title="source node traceability is present",
+        severity="high",
+        weight=8,
+        match_key="source_map",
+        match_value="present",
+        plain_language="source node traceability is present; keep the review focused on user intent and source traceability.",
+        user_question="Keep traceability visible but collapsed.",
+        recommended_action="preserve_traceability",
+        quiet_copy="Show this as a compact signal and keep details collapsed until the user asks.",
+        report_copy="Use this signal to explain why the item belongs in the current trust queue.",
+        evidence_prompt="Compare the saved reason with source evidence before changing status.",
+        reduces_pressure=True,
+    ),
+    TrustRuleDefinition(
+        rule_id="trule_140_boundary_AI-inferred",
+        dimension="boundary",
+        title="saved reason is AI-inferred",
+        severity="critical",
+        weight=9,
+        match_key="boundary",
+        match_value="AI-inferred",
+        plain_language="saved reason is AI-inferred; keep the review focused on user intent and source traceability.",
+        user_question="Ask whether this saved reason reflects the user, not the model.",
+        recommended_action="review_ai_inference",
+        quiet_copy="Show this as a compact signal and keep details collapsed until the user asks.",
+        report_copy="Use this signal to explain why the item belongs in the current trust queue.",
+        evidence_prompt="Compare the saved reason with source evidence before changing status.",
+        reduces_pressure=True,
+    ),
+    TrustRuleDefinition(
+        rule_id="trule_141_boundary_user-stated",
+        dimension="boundary",
+        title="saved reason was written by the user",
+        severity="high",
+        weight=10,
+        match_key="boundary",
+        match_value="user-stated",
+        plain_language="saved reason was written by the user; keep the review focused on user intent and source traceability.",
+        user_question="Protect the user-stated reason and avoid rewriting it without intent.",
+        recommended_action="preserve_user_reason",
+        quiet_copy="Show this as a compact signal and keep details collapsed until the user asks.",
+        report_copy="Use this signal to explain why the item belongs in the current trust queue.",
+        evidence_prompt="Compare the saved reason with source evidence before changing status.",
+        reduces_pressure=True,
+    ),
+    TrustRuleDefinition(
+        rule_id="trule_142_boundary_unknown",
+        dimension="boundary",
+        title="saved reason boundary is unknown",
+        severity="medium",
+        weight=11,
+        match_key="boundary",
+        match_value="unknown",
+        plain_language="saved reason boundary is unknown; keep the review focused on user intent and source traceability.",
+        user_question="Clarify whether this context came from the user or the system.",
+        recommended_action="inspect_boundary",
+        quiet_copy="Show this as a compact signal and keep details collapsed until the user asks.",
+        report_copy="Use this signal to explain why the item belongs in the current trust queue.",
+        evidence_prompt="Compare the saved reason with source evidence before changing status.",
+        reduces_pressure=True,
+    ),
+    TrustRuleDefinition(
+        rule_id="trule_143_status_unreviewed",
+        dimension="status",
+        title="review status is still unreviewed",
+        severity="high",
+        weight=12,
+        match_key="status",
+        match_value="unreviewed",
+        plain_language="review status is still unreviewed; keep the review focused on user intent and source traceability.",
+        user_question="Make a decision only after the evidence path is visible.",
+        recommended_action="review_now",
+        quiet_copy="Show this as a compact signal and keep details collapsed until the user asks.",
+        report_copy="Use this signal to explain why the item belongs in the current trust queue.",
+        evidence_prompt="Compare the saved reason with source evidence before changing status.",
+        reduces_pressure=True,
+    ),
+)
+
+EVIDENCE_COMPRESSION_PATTERNS: tuple[EvidenceCompressionPattern, ...] = (
+    EvidenceCompressionPattern(
+        pattern_id="epat_000_triggered_thought",
+        relation="triggered_thought",
+        bucket="supporting",
+        priority=1,
+        label="Saved reason path",
+        summary_template="{count} path(s) use triggered_thought as the main evidence relation.",
+        reviewer_question="Does the triggered_thought relation actually support the saved reason?",
+        missing_prompt="If this relation is missing, rely on the source text instead of graph proximity.",
+        support_copy="This relation can support a compact evidence statement.",
+        caution_copy="Do not expose every path unless the user expands the evidence section.",
+        quiet_copy="Compress triggered_thought paths into one plain-language line.",
+        report_copy="Report triggered_thought only as a decision aid, not as proof of user intent.",
+    ),
+    EvidenceCompressionPattern(
+        pattern_id="epat_001_evidence_for",
+        relation="evidence_for",
+        bucket="supporting",
+        priority=2,
+        label="Evidence support",
+        summary_template="{count} path(s) use evidence_for as the main evidence relation.",
+        reviewer_question="Does the evidence_for relation actually support the saved reason?",
+        missing_prompt="If this relation is missing, rely on the source text instead of graph proximity.",
+        support_copy="This relation can support a compact evidence statement.",
+        caution_copy="Do not expose every path unless the user expands the evidence section.",
+        quiet_copy="Compress evidence_for paths into one plain-language line.",
+        report_copy="Report evidence_for only as a decision aid, not as proof of user intent.",
+    ),
+    EvidenceCompressionPattern(
+        pattern_id="epat_002_belongs_to",
+        relation="belongs_to",
+        bucket="supporting",
+        priority=3,
+        label="Project connection",
+        summary_template="{count} path(s) use belongs_to as the main evidence relation.",
+        reviewer_question="Does the belongs_to relation actually support the saved reason?",
+        missing_prompt="If this relation is missing, rely on the source text instead of graph proximity.",
+        support_copy="This relation can support a compact evidence statement.",
+        caution_copy="Do not expose every path unless the user expands the evidence section.",
+        quiet_copy="Compress belongs_to paths into one plain-language line.",
+        report_copy="Report belongs_to only as a decision aid, not as proof of user intent.",
+    ),
+    EvidenceCompressionPattern(
+        pattern_id="epat_003_follow_up",
+        relation="follow_up",
+        bucket="needs_confirmation",
+        priority=4,
+        label="Open loop path",
+        summary_template="{count} path(s) use follow_up as the main evidence relation.",
+        reviewer_question="Does the follow_up relation actually support the saved reason?",
+        missing_prompt="If this relation is missing, rely on the source text instead of graph proximity.",
+        support_copy="This relation can support a compact evidence statement.",
+        caution_copy="Do not expose every path unless the user expands the evidence section.",
+        quiet_copy="Compress follow_up paths into one plain-language line.",
+        report_copy="Report follow_up only as a decision aid, not as proof of user intent.",
+    ),
+    EvidenceCompressionPattern(
+        pattern_id="epat_004_mentions",
+        relation="mentions",
+        bucket="supporting",
+        priority=5,
+        label="Mention context",
+        summary_template="{count} path(s) use mentions as the main evidence relation.",
+        reviewer_question="Does the mentions relation actually support the saved reason?",
+        missing_prompt="If this relation is missing, rely on the source text instead of graph proximity.",
+        support_copy="This relation can support a compact evidence statement.",
+        caution_copy="Do not expose every path unless the user expands the evidence section.",
+        quiet_copy="Compress mentions paths into one plain-language line.",
+        report_copy="Report mentions only as a decision aid, not as proof of user intent.",
+    ),
+    EvidenceCompressionPattern(
+        pattern_id="epat_005_contradicts",
+        relation="contradicts",
+        bucket="insufficient",
+        priority=6,
+        label="Potential conflict",
+        summary_template="{count} path(s) use contradicts as the main evidence relation.",
+        reviewer_question="Does the contradicts relation actually support the saved reason?",
+        missing_prompt="If this relation is missing, rely on the source text instead of graph proximity.",
+        support_copy="This relation can support a compact evidence statement.",
+        caution_copy="Do not expose every path unless the user expands the evidence section.",
+        quiet_copy="Compress contradicts paths into one plain-language line.",
+        report_copy="Report contradicts only as a decision aid, not as proof of user intent.",
+    ),
+    EvidenceCompressionPattern(
+        pattern_id="epat_006_derived_from",
+        relation="derived_from",
+        bucket="supporting",
+        priority=7,
+        label="Derived context",
+        summary_template="{count} path(s) use derived_from as the main evidence relation.",
+        reviewer_question="Does the derived_from relation actually support the saved reason?",
+        missing_prompt="If this relation is missing, rely on the source text instead of graph proximity.",
+        support_copy="This relation can support a compact evidence statement.",
+        caution_copy="Do not expose every path unless the user expands the evidence section.",
+        quiet_copy="Compress derived_from paths into one plain-language line.",
+        report_copy="Report derived_from only as a decision aid, not as proof of user intent.",
+    ),
+    EvidenceCompressionPattern(
+        pattern_id="epat_007_related_to",
+        relation="related_to",
+        bucket="needs_confirmation",
+        priority=8,
+        label="Weak relation",
+        summary_template="{count} path(s) use related_to as the main evidence relation.",
+        reviewer_question="Does the related_to relation actually support the saved reason?",
+        missing_prompt="If this relation is missing, rely on the source text instead of graph proximity.",
+        support_copy="This relation can support a compact evidence statement.",
+        caution_copy="Do not expose every path unless the user expands the evidence section.",
+        quiet_copy="Compress related_to paths into one plain-language line.",
+        report_copy="Report related_to only as a decision aid, not as proof of user intent.",
+    ),
+    EvidenceCompressionPattern(
+        pattern_id="epat_008_triggered_thought",
+        relation="triggered_thought",
+        bucket="supporting",
+        priority=9,
+        label="Saved reason path",
+        summary_template="{count} path(s) use triggered_thought as the main evidence relation.",
+        reviewer_question="Does the triggered_thought relation actually support the saved reason?",
+        missing_prompt="If this relation is missing, rely on the source text instead of graph proximity.",
+        support_copy="This relation can support a compact evidence statement.",
+        caution_copy="Do not expose every path unless the user expands the evidence section.",
+        quiet_copy="Compress triggered_thought paths into one plain-language line.",
+        report_copy="Report triggered_thought only as a decision aid, not as proof of user intent.",
+    ),
+    EvidenceCompressionPattern(
+        pattern_id="epat_009_evidence_for",
+        relation="evidence_for",
+        bucket="supporting",
+        priority=1,
+        label="Evidence support",
+        summary_template="{count} path(s) use evidence_for as the main evidence relation.",
+        reviewer_question="Does the evidence_for relation actually support the saved reason?",
+        missing_prompt="If this relation is missing, rely on the source text instead of graph proximity.",
+        support_copy="This relation can support a compact evidence statement.",
+        caution_copy="Do not expose every path unless the user expands the evidence section.",
+        quiet_copy="Compress evidence_for paths into one plain-language line.",
+        report_copy="Report evidence_for only as a decision aid, not as proof of user intent.",
+    ),
+    EvidenceCompressionPattern(
+        pattern_id="epat_010_belongs_to",
+        relation="belongs_to",
+        bucket="supporting",
+        priority=2,
+        label="Project connection",
+        summary_template="{count} path(s) use belongs_to as the main evidence relation.",
+        reviewer_question="Does the belongs_to relation actually support the saved reason?",
+        missing_prompt="If this relation is missing, rely on the source text instead of graph proximity.",
+        support_copy="This relation can support a compact evidence statement.",
+        caution_copy="Do not expose every path unless the user expands the evidence section.",
+        quiet_copy="Compress belongs_to paths into one plain-language line.",
+        report_copy="Report belongs_to only as a decision aid, not as proof of user intent.",
+    ),
+    EvidenceCompressionPattern(
+        pattern_id="epat_011_follow_up",
+        relation="follow_up",
+        bucket="needs_confirmation",
+        priority=3,
+        label="Open loop path",
+        summary_template="{count} path(s) use follow_up as the main evidence relation.",
+        reviewer_question="Does the follow_up relation actually support the saved reason?",
+        missing_prompt="If this relation is missing, rely on the source text instead of graph proximity.",
+        support_copy="This relation can support a compact evidence statement.",
+        caution_copy="Do not expose every path unless the user expands the evidence section.",
+        quiet_copy="Compress follow_up paths into one plain-language line.",
+        report_copy="Report follow_up only as a decision aid, not as proof of user intent.",
+    ),
+    EvidenceCompressionPattern(
+        pattern_id="epat_012_mentions",
+        relation="mentions",
+        bucket="supporting",
+        priority=4,
+        label="Mention context",
+        summary_template="{count} path(s) use mentions as the main evidence relation.",
+        reviewer_question="Does the mentions relation actually support the saved reason?",
+        missing_prompt="If this relation is missing, rely on the source text instead of graph proximity.",
+        support_copy="This relation can support a compact evidence statement.",
+        caution_copy="Do not expose every path unless the user expands the evidence section.",
+        quiet_copy="Compress mentions paths into one plain-language line.",
+        report_copy="Report mentions only as a decision aid, not as proof of user intent.",
+    ),
+    EvidenceCompressionPattern(
+        pattern_id="epat_013_contradicts",
+        relation="contradicts",
+        bucket="insufficient",
+        priority=5,
+        label="Potential conflict",
+        summary_template="{count} path(s) use contradicts as the main evidence relation.",
+        reviewer_question="Does the contradicts relation actually support the saved reason?",
+        missing_prompt="If this relation is missing, rely on the source text instead of graph proximity.",
+        support_copy="This relation can support a compact evidence statement.",
+        caution_copy="Do not expose every path unless the user expands the evidence section.",
+        quiet_copy="Compress contradicts paths into one plain-language line.",
+        report_copy="Report contradicts only as a decision aid, not as proof of user intent.",
+    ),
+    EvidenceCompressionPattern(
+        pattern_id="epat_014_derived_from",
+        relation="derived_from",
+        bucket="supporting",
+        priority=6,
+        label="Derived context",
+        summary_template="{count} path(s) use derived_from as the main evidence relation.",
+        reviewer_question="Does the derived_from relation actually support the saved reason?",
+        missing_prompt="If this relation is missing, rely on the source text instead of graph proximity.",
+        support_copy="This relation can support a compact evidence statement.",
+        caution_copy="Do not expose every path unless the user expands the evidence section.",
+        quiet_copy="Compress derived_from paths into one plain-language line.",
+        report_copy="Report derived_from only as a decision aid, not as proof of user intent.",
+    ),
+    EvidenceCompressionPattern(
+        pattern_id="epat_015_related_to",
+        relation="related_to",
+        bucket="needs_confirmation",
+        priority=7,
+        label="Weak relation",
+        summary_template="{count} path(s) use related_to as the main evidence relation.",
+        reviewer_question="Does the related_to relation actually support the saved reason?",
+        missing_prompt="If this relation is missing, rely on the source text instead of graph proximity.",
+        support_copy="This relation can support a compact evidence statement.",
+        caution_copy="Do not expose every path unless the user expands the evidence section.",
+        quiet_copy="Compress related_to paths into one plain-language line.",
+        report_copy="Report related_to only as a decision aid, not as proof of user intent.",
+    ),
+    EvidenceCompressionPattern(
+        pattern_id="epat_016_triggered_thought",
+        relation="triggered_thought",
+        bucket="supporting",
+        priority=8,
+        label="Saved reason path",
+        summary_template="{count} path(s) use triggered_thought as the main evidence relation.",
+        reviewer_question="Does the triggered_thought relation actually support the saved reason?",
+        missing_prompt="If this relation is missing, rely on the source text instead of graph proximity.",
+        support_copy="This relation can support a compact evidence statement.",
+        caution_copy="Do not expose every path unless the user expands the evidence section.",
+        quiet_copy="Compress triggered_thought paths into one plain-language line.",
+        report_copy="Report triggered_thought only as a decision aid, not as proof of user intent.",
+    ),
+    EvidenceCompressionPattern(
+        pattern_id="epat_017_evidence_for",
+        relation="evidence_for",
+        bucket="supporting",
+        priority=9,
+        label="Evidence support",
+        summary_template="{count} path(s) use evidence_for as the main evidence relation.",
+        reviewer_question="Does the evidence_for relation actually support the saved reason?",
+        missing_prompt="If this relation is missing, rely on the source text instead of graph proximity.",
+        support_copy="This relation can support a compact evidence statement.",
+        caution_copy="Do not expose every path unless the user expands the evidence section.",
+        quiet_copy="Compress evidence_for paths into one plain-language line.",
+        report_copy="Report evidence_for only as a decision aid, not as proof of user intent.",
+    ),
+    EvidenceCompressionPattern(
+        pattern_id="epat_018_belongs_to",
+        relation="belongs_to",
+        bucket="supporting",
+        priority=1,
+        label="Project connection",
+        summary_template="{count} path(s) use belongs_to as the main evidence relation.",
+        reviewer_question="Does the belongs_to relation actually support the saved reason?",
+        missing_prompt="If this relation is missing, rely on the source text instead of graph proximity.",
+        support_copy="This relation can support a compact evidence statement.",
+        caution_copy="Do not expose every path unless the user expands the evidence section.",
+        quiet_copy="Compress belongs_to paths into one plain-language line.",
+        report_copy="Report belongs_to only as a decision aid, not as proof of user intent.",
+    ),
+    EvidenceCompressionPattern(
+        pattern_id="epat_019_follow_up",
+        relation="follow_up",
+        bucket="needs_confirmation",
+        priority=2,
+        label="Open loop path",
+        summary_template="{count} path(s) use follow_up as the main evidence relation.",
+        reviewer_question="Does the follow_up relation actually support the saved reason?",
+        missing_prompt="If this relation is missing, rely on the source text instead of graph proximity.",
+        support_copy="This relation can support a compact evidence statement.",
+        caution_copy="Do not expose every path unless the user expands the evidence section.",
+        quiet_copy="Compress follow_up paths into one plain-language line.",
+        report_copy="Report follow_up only as a decision aid, not as proof of user intent.",
+    ),
+    EvidenceCompressionPattern(
+        pattern_id="epat_020_mentions",
+        relation="mentions",
+        bucket="supporting",
+        priority=3,
+        label="Mention context",
+        summary_template="{count} path(s) use mentions as the main evidence relation.",
+        reviewer_question="Does the mentions relation actually support the saved reason?",
+        missing_prompt="If this relation is missing, rely on the source text instead of graph proximity.",
+        support_copy="This relation can support a compact evidence statement.",
+        caution_copy="Do not expose every path unless the user expands the evidence section.",
+        quiet_copy="Compress mentions paths into one plain-language line.",
+        report_copy="Report mentions only as a decision aid, not as proof of user intent.",
+    ),
+    EvidenceCompressionPattern(
+        pattern_id="epat_021_contradicts",
+        relation="contradicts",
+        bucket="insufficient",
+        priority=4,
+        label="Potential conflict",
+        summary_template="{count} path(s) use contradicts as the main evidence relation.",
+        reviewer_question="Does the contradicts relation actually support the saved reason?",
+        missing_prompt="If this relation is missing, rely on the source text instead of graph proximity.",
+        support_copy="This relation can support a compact evidence statement.",
+        caution_copy="Do not expose every path unless the user expands the evidence section.",
+        quiet_copy="Compress contradicts paths into one plain-language line.",
+        report_copy="Report contradicts only as a decision aid, not as proof of user intent.",
+    ),
+    EvidenceCompressionPattern(
+        pattern_id="epat_022_derived_from",
+        relation="derived_from",
+        bucket="supporting",
+        priority=5,
+        label="Derived context",
+        summary_template="{count} path(s) use derived_from as the main evidence relation.",
+        reviewer_question="Does the derived_from relation actually support the saved reason?",
+        missing_prompt="If this relation is missing, rely on the source text instead of graph proximity.",
+        support_copy="This relation can support a compact evidence statement.",
+        caution_copy="Do not expose every path unless the user expands the evidence section.",
+        quiet_copy="Compress derived_from paths into one plain-language line.",
+        report_copy="Report derived_from only as a decision aid, not as proof of user intent.",
+    ),
+    EvidenceCompressionPattern(
+        pattern_id="epat_023_related_to",
+        relation="related_to",
+        bucket="needs_confirmation",
+        priority=6,
+        label="Weak relation",
+        summary_template="{count} path(s) use related_to as the main evidence relation.",
+        reviewer_question="Does the related_to relation actually support the saved reason?",
+        missing_prompt="If this relation is missing, rely on the source text instead of graph proximity.",
+        support_copy="This relation can support a compact evidence statement.",
+        caution_copy="Do not expose every path unless the user expands the evidence section.",
+        quiet_copy="Compress related_to paths into one plain-language line.",
+        report_copy="Report related_to only as a decision aid, not as proof of user intent.",
+    ),
+    EvidenceCompressionPattern(
+        pattern_id="epat_024_triggered_thought",
+        relation="triggered_thought",
+        bucket="supporting",
+        priority=7,
+        label="Saved reason path",
+        summary_template="{count} path(s) use triggered_thought as the main evidence relation.",
+        reviewer_question="Does the triggered_thought relation actually support the saved reason?",
+        missing_prompt="If this relation is missing, rely on the source text instead of graph proximity.",
+        support_copy="This relation can support a compact evidence statement.",
+        caution_copy="Do not expose every path unless the user expands the evidence section.",
+        quiet_copy="Compress triggered_thought paths into one plain-language line.",
+        report_copy="Report triggered_thought only as a decision aid, not as proof of user intent.",
+    ),
+    EvidenceCompressionPattern(
+        pattern_id="epat_025_evidence_for",
+        relation="evidence_for",
+        bucket="supporting",
+        priority=8,
+        label="Evidence support",
+        summary_template="{count} path(s) use evidence_for as the main evidence relation.",
+        reviewer_question="Does the evidence_for relation actually support the saved reason?",
+        missing_prompt="If this relation is missing, rely on the source text instead of graph proximity.",
+        support_copy="This relation can support a compact evidence statement.",
+        caution_copy="Do not expose every path unless the user expands the evidence section.",
+        quiet_copy="Compress evidence_for paths into one plain-language line.",
+        report_copy="Report evidence_for only as a decision aid, not as proof of user intent.",
+    ),
+    EvidenceCompressionPattern(
+        pattern_id="epat_026_belongs_to",
+        relation="belongs_to",
+        bucket="supporting",
+        priority=9,
+        label="Project connection",
+        summary_template="{count} path(s) use belongs_to as the main evidence relation.",
+        reviewer_question="Does the belongs_to relation actually support the saved reason?",
+        missing_prompt="If this relation is missing, rely on the source text instead of graph proximity.",
+        support_copy="This relation can support a compact evidence statement.",
+        caution_copy="Do not expose every path unless the user expands the evidence section.",
+        quiet_copy="Compress belongs_to paths into one plain-language line.",
+        report_copy="Report belongs_to only as a decision aid, not as proof of user intent.",
+    ),
+    EvidenceCompressionPattern(
+        pattern_id="epat_027_follow_up",
+        relation="follow_up",
+        bucket="needs_confirmation",
+        priority=1,
+        label="Open loop path",
+        summary_template="{count} path(s) use follow_up as the main evidence relation.",
+        reviewer_question="Does the follow_up relation actually support the saved reason?",
+        missing_prompt="If this relation is missing, rely on the source text instead of graph proximity.",
+        support_copy="This relation can support a compact evidence statement.",
+        caution_copy="Do not expose every path unless the user expands the evidence section.",
+        quiet_copy="Compress follow_up paths into one plain-language line.",
+        report_copy="Report follow_up only as a decision aid, not as proof of user intent.",
+    ),
+    EvidenceCompressionPattern(
+        pattern_id="epat_028_mentions",
+        relation="mentions",
+        bucket="supporting",
+        priority=2,
+        label="Mention context",
+        summary_template="{count} path(s) use mentions as the main evidence relation.",
+        reviewer_question="Does the mentions relation actually support the saved reason?",
+        missing_prompt="If this relation is missing, rely on the source text instead of graph proximity.",
+        support_copy="This relation can support a compact evidence statement.",
+        caution_copy="Do not expose every path unless the user expands the evidence section.",
+        quiet_copy="Compress mentions paths into one plain-language line.",
+        report_copy="Report mentions only as a decision aid, not as proof of user intent.",
+    ),
+    EvidenceCompressionPattern(
+        pattern_id="epat_029_contradicts",
+        relation="contradicts",
+        bucket="insufficient",
+        priority=3,
+        label="Potential conflict",
+        summary_template="{count} path(s) use contradicts as the main evidence relation.",
+        reviewer_question="Does the contradicts relation actually support the saved reason?",
+        missing_prompt="If this relation is missing, rely on the source text instead of graph proximity.",
+        support_copy="This relation can support a compact evidence statement.",
+        caution_copy="Do not expose every path unless the user expands the evidence section.",
+        quiet_copy="Compress contradicts paths into one plain-language line.",
+        report_copy="Report contradicts only as a decision aid, not as proof of user intent.",
+    ),
+    EvidenceCompressionPattern(
+        pattern_id="epat_030_derived_from",
+        relation="derived_from",
+        bucket="supporting",
+        priority=4,
+        label="Derived context",
+        summary_template="{count} path(s) use derived_from as the main evidence relation.",
+        reviewer_question="Does the derived_from relation actually support the saved reason?",
+        missing_prompt="If this relation is missing, rely on the source text instead of graph proximity.",
+        support_copy="This relation can support a compact evidence statement.",
+        caution_copy="Do not expose every path unless the user expands the evidence section.",
+        quiet_copy="Compress derived_from paths into one plain-language line.",
+        report_copy="Report derived_from only as a decision aid, not as proof of user intent.",
+    ),
+    EvidenceCompressionPattern(
+        pattern_id="epat_031_related_to",
+        relation="related_to",
+        bucket="needs_confirmation",
+        priority=5,
+        label="Weak relation",
+        summary_template="{count} path(s) use related_to as the main evidence relation.",
+        reviewer_question="Does the related_to relation actually support the saved reason?",
+        missing_prompt="If this relation is missing, rely on the source text instead of graph proximity.",
+        support_copy="This relation can support a compact evidence statement.",
+        caution_copy="Do not expose every path unless the user expands the evidence section.",
+        quiet_copy="Compress related_to paths into one plain-language line.",
+        report_copy="Report related_to only as a decision aid, not as proof of user intent.",
+    ),
+    EvidenceCompressionPattern(
+        pattern_id="epat_032_triggered_thought",
+        relation="triggered_thought",
+        bucket="supporting",
+        priority=6,
+        label="Saved reason path",
+        summary_template="{count} path(s) use triggered_thought as the main evidence relation.",
+        reviewer_question="Does the triggered_thought relation actually support the saved reason?",
+        missing_prompt="If this relation is missing, rely on the source text instead of graph proximity.",
+        support_copy="This relation can support a compact evidence statement.",
+        caution_copy="Do not expose every path unless the user expands the evidence section.",
+        quiet_copy="Compress triggered_thought paths into one plain-language line.",
+        report_copy="Report triggered_thought only as a decision aid, not as proof of user intent.",
+    ),
+    EvidenceCompressionPattern(
+        pattern_id="epat_033_evidence_for",
+        relation="evidence_for",
+        bucket="supporting",
+        priority=7,
+        label="Evidence support",
+        summary_template="{count} path(s) use evidence_for as the main evidence relation.",
+        reviewer_question="Does the evidence_for relation actually support the saved reason?",
+        missing_prompt="If this relation is missing, rely on the source text instead of graph proximity.",
+        support_copy="This relation can support a compact evidence statement.",
+        caution_copy="Do not expose every path unless the user expands the evidence section.",
+        quiet_copy="Compress evidence_for paths into one plain-language line.",
+        report_copy="Report evidence_for only as a decision aid, not as proof of user intent.",
+    ),
+    EvidenceCompressionPattern(
+        pattern_id="epat_034_belongs_to",
+        relation="belongs_to",
+        bucket="supporting",
+        priority=8,
+        label="Project connection",
+        summary_template="{count} path(s) use belongs_to as the main evidence relation.",
+        reviewer_question="Does the belongs_to relation actually support the saved reason?",
+        missing_prompt="If this relation is missing, rely on the source text instead of graph proximity.",
+        support_copy="This relation can support a compact evidence statement.",
+        caution_copy="Do not expose every path unless the user expands the evidence section.",
+        quiet_copy="Compress belongs_to paths into one plain-language line.",
+        report_copy="Report belongs_to only as a decision aid, not as proof of user intent.",
+    ),
+    EvidenceCompressionPattern(
+        pattern_id="epat_035_follow_up",
+        relation="follow_up",
+        bucket="needs_confirmation",
+        priority=9,
+        label="Open loop path",
+        summary_template="{count} path(s) use follow_up as the main evidence relation.",
+        reviewer_question="Does the follow_up relation actually support the saved reason?",
+        missing_prompt="If this relation is missing, rely on the source text instead of graph proximity.",
+        support_copy="This relation can support a compact evidence statement.",
+        caution_copy="Do not expose every path unless the user expands the evidence section.",
+        quiet_copy="Compress follow_up paths into one plain-language line.",
+        report_copy="Report follow_up only as a decision aid, not as proof of user intent.",
+    ),
+    EvidenceCompressionPattern(
+        pattern_id="epat_036_mentions",
+        relation="mentions",
+        bucket="supporting",
+        priority=1,
+        label="Mention context",
+        summary_template="{count} path(s) use mentions as the main evidence relation.",
+        reviewer_question="Does the mentions relation actually support the saved reason?",
+        missing_prompt="If this relation is missing, rely on the source text instead of graph proximity.",
+        support_copy="This relation can support a compact evidence statement.",
+        caution_copy="Do not expose every path unless the user expands the evidence section.",
+        quiet_copy="Compress mentions paths into one plain-language line.",
+        report_copy="Report mentions only as a decision aid, not as proof of user intent.",
+    ),
+    EvidenceCompressionPattern(
+        pattern_id="epat_037_contradicts",
+        relation="contradicts",
+        bucket="insufficient",
+        priority=2,
+        label="Potential conflict",
+        summary_template="{count} path(s) use contradicts as the main evidence relation.",
+        reviewer_question="Does the contradicts relation actually support the saved reason?",
+        missing_prompt="If this relation is missing, rely on the source text instead of graph proximity.",
+        support_copy="This relation can support a compact evidence statement.",
+        caution_copy="Do not expose every path unless the user expands the evidence section.",
+        quiet_copy="Compress contradicts paths into one plain-language line.",
+        report_copy="Report contradicts only as a decision aid, not as proof of user intent.",
+    ),
+    EvidenceCompressionPattern(
+        pattern_id="epat_038_derived_from",
+        relation="derived_from",
+        bucket="supporting",
+        priority=3,
+        label="Derived context",
+        summary_template="{count} path(s) use derived_from as the main evidence relation.",
+        reviewer_question="Does the derived_from relation actually support the saved reason?",
+        missing_prompt="If this relation is missing, rely on the source text instead of graph proximity.",
+        support_copy="This relation can support a compact evidence statement.",
+        caution_copy="Do not expose every path unless the user expands the evidence section.",
+        quiet_copy="Compress derived_from paths into one plain-language line.",
+        report_copy="Report derived_from only as a decision aid, not as proof of user intent.",
+    ),
+    EvidenceCompressionPattern(
+        pattern_id="epat_039_related_to",
+        relation="related_to",
+        bucket="needs_confirmation",
+        priority=4,
+        label="Weak relation",
+        summary_template="{count} path(s) use related_to as the main evidence relation.",
+        reviewer_question="Does the related_to relation actually support the saved reason?",
+        missing_prompt="If this relation is missing, rely on the source text instead of graph proximity.",
+        support_copy="This relation can support a compact evidence statement.",
+        caution_copy="Do not expose every path unless the user expands the evidence section.",
+        quiet_copy="Compress related_to paths into one plain-language line.",
+        report_copy="Report related_to only as a decision aid, not as proof of user intent.",
+    ),
+    EvidenceCompressionPattern(
+        pattern_id="epat_040_triggered_thought",
+        relation="triggered_thought",
+        bucket="supporting",
+        priority=5,
+        label="Saved reason path",
+        summary_template="{count} path(s) use triggered_thought as the main evidence relation.",
+        reviewer_question="Does the triggered_thought relation actually support the saved reason?",
+        missing_prompt="If this relation is missing, rely on the source text instead of graph proximity.",
+        support_copy="This relation can support a compact evidence statement.",
+        caution_copy="Do not expose every path unless the user expands the evidence section.",
+        quiet_copy="Compress triggered_thought paths into one plain-language line.",
+        report_copy="Report triggered_thought only as a decision aid, not as proof of user intent.",
+    ),
+    EvidenceCompressionPattern(
+        pattern_id="epat_041_evidence_for",
+        relation="evidence_for",
+        bucket="supporting",
+        priority=6,
+        label="Evidence support",
+        summary_template="{count} path(s) use evidence_for as the main evidence relation.",
+        reviewer_question="Does the evidence_for relation actually support the saved reason?",
+        missing_prompt="If this relation is missing, rely on the source text instead of graph proximity.",
+        support_copy="This relation can support a compact evidence statement.",
+        caution_copy="Do not expose every path unless the user expands the evidence section.",
+        quiet_copy="Compress evidence_for paths into one plain-language line.",
+        report_copy="Report evidence_for only as a decision aid, not as proof of user intent.",
+    ),
+    EvidenceCompressionPattern(
+        pattern_id="epat_042_belongs_to",
+        relation="belongs_to",
+        bucket="supporting",
+        priority=7,
+        label="Project connection",
+        summary_template="{count} path(s) use belongs_to as the main evidence relation.",
+        reviewer_question="Does the belongs_to relation actually support the saved reason?",
+        missing_prompt="If this relation is missing, rely on the source text instead of graph proximity.",
+        support_copy="This relation can support a compact evidence statement.",
+        caution_copy="Do not expose every path unless the user expands the evidence section.",
+        quiet_copy="Compress belongs_to paths into one plain-language line.",
+        report_copy="Report belongs_to only as a decision aid, not as proof of user intent.",
+    ),
+    EvidenceCompressionPattern(
+        pattern_id="epat_043_follow_up",
+        relation="follow_up",
+        bucket="needs_confirmation",
+        priority=8,
+        label="Open loop path",
+        summary_template="{count} path(s) use follow_up as the main evidence relation.",
+        reviewer_question="Does the follow_up relation actually support the saved reason?",
+        missing_prompt="If this relation is missing, rely on the source text instead of graph proximity.",
+        support_copy="This relation can support a compact evidence statement.",
+        caution_copy="Do not expose every path unless the user expands the evidence section.",
+        quiet_copy="Compress follow_up paths into one plain-language line.",
+        report_copy="Report follow_up only as a decision aid, not as proof of user intent.",
+    ),
+    EvidenceCompressionPattern(
+        pattern_id="epat_044_mentions",
+        relation="mentions",
+        bucket="supporting",
+        priority=9,
+        label="Mention context",
+        summary_template="{count} path(s) use mentions as the main evidence relation.",
+        reviewer_question="Does the mentions relation actually support the saved reason?",
+        missing_prompt="If this relation is missing, rely on the source text instead of graph proximity.",
+        support_copy="This relation can support a compact evidence statement.",
+        caution_copy="Do not expose every path unless the user expands the evidence section.",
+        quiet_copy="Compress mentions paths into one plain-language line.",
+        report_copy="Report mentions only as a decision aid, not as proof of user intent.",
+    ),
+    EvidenceCompressionPattern(
+        pattern_id="epat_045_contradicts",
+        relation="contradicts",
+        bucket="insufficient",
+        priority=1,
+        label="Potential conflict",
+        summary_template="{count} path(s) use contradicts as the main evidence relation.",
+        reviewer_question="Does the contradicts relation actually support the saved reason?",
+        missing_prompt="If this relation is missing, rely on the source text instead of graph proximity.",
+        support_copy="This relation can support a compact evidence statement.",
+        caution_copy="Do not expose every path unless the user expands the evidence section.",
+        quiet_copy="Compress contradicts paths into one plain-language line.",
+        report_copy="Report contradicts only as a decision aid, not as proof of user intent.",
+    ),
+    EvidenceCompressionPattern(
+        pattern_id="epat_046_derived_from",
+        relation="derived_from",
+        bucket="supporting",
+        priority=2,
+        label="Derived context",
+        summary_template="{count} path(s) use derived_from as the main evidence relation.",
+        reviewer_question="Does the derived_from relation actually support the saved reason?",
+        missing_prompt="If this relation is missing, rely on the source text instead of graph proximity.",
+        support_copy="This relation can support a compact evidence statement.",
+        caution_copy="Do not expose every path unless the user expands the evidence section.",
+        quiet_copy="Compress derived_from paths into one plain-language line.",
+        report_copy="Report derived_from only as a decision aid, not as proof of user intent.",
+    ),
+    EvidenceCompressionPattern(
+        pattern_id="epat_047_related_to",
+        relation="related_to",
+        bucket="needs_confirmation",
+        priority=3,
+        label="Weak relation",
+        summary_template="{count} path(s) use related_to as the main evidence relation.",
+        reviewer_question="Does the related_to relation actually support the saved reason?",
+        missing_prompt="If this relation is missing, rely on the source text instead of graph proximity.",
+        support_copy="This relation can support a compact evidence statement.",
+        caution_copy="Do not expose every path unless the user expands the evidence section.",
+        quiet_copy="Compress related_to paths into one plain-language line.",
+        report_copy="Report related_to only as a decision aid, not as proof of user intent.",
+    ),
+    EvidenceCompressionPattern(
+        pattern_id="epat_048_triggered_thought",
+        relation="triggered_thought",
+        bucket="supporting",
+        priority=4,
+        label="Saved reason path",
+        summary_template="{count} path(s) use triggered_thought as the main evidence relation.",
+        reviewer_question="Does the triggered_thought relation actually support the saved reason?",
+        missing_prompt="If this relation is missing, rely on the source text instead of graph proximity.",
+        support_copy="This relation can support a compact evidence statement.",
+        caution_copy="Do not expose every path unless the user expands the evidence section.",
+        quiet_copy="Compress triggered_thought paths into one plain-language line.",
+        report_copy="Report triggered_thought only as a decision aid, not as proof of user intent.",
+    ),
+    EvidenceCompressionPattern(
+        pattern_id="epat_049_evidence_for",
+        relation="evidence_for",
+        bucket="supporting",
+        priority=5,
+        label="Evidence support",
+        summary_template="{count} path(s) use evidence_for as the main evidence relation.",
+        reviewer_question="Does the evidence_for relation actually support the saved reason?",
+        missing_prompt="If this relation is missing, rely on the source text instead of graph proximity.",
+        support_copy="This relation can support a compact evidence statement.",
+        caution_copy="Do not expose every path unless the user expands the evidence section.",
+        quiet_copy="Compress evidence_for paths into one plain-language line.",
+        report_copy="Report evidence_for only as a decision aid, not as proof of user intent.",
+    ),
+    EvidenceCompressionPattern(
+        pattern_id="epat_050_belongs_to",
+        relation="belongs_to",
+        bucket="supporting",
+        priority=6,
+        label="Project connection",
+        summary_template="{count} path(s) use belongs_to as the main evidence relation.",
+        reviewer_question="Does the belongs_to relation actually support the saved reason?",
+        missing_prompt="If this relation is missing, rely on the source text instead of graph proximity.",
+        support_copy="This relation can support a compact evidence statement.",
+        caution_copy="Do not expose every path unless the user expands the evidence section.",
+        quiet_copy="Compress belongs_to paths into one plain-language line.",
+        report_copy="Report belongs_to only as a decision aid, not as proof of user intent.",
+    ),
+    EvidenceCompressionPattern(
+        pattern_id="epat_051_follow_up",
+        relation="follow_up",
+        bucket="needs_confirmation",
+        priority=7,
+        label="Open loop path",
+        summary_template="{count} path(s) use follow_up as the main evidence relation.",
+        reviewer_question="Does the follow_up relation actually support the saved reason?",
+        missing_prompt="If this relation is missing, rely on the source text instead of graph proximity.",
+        support_copy="This relation can support a compact evidence statement.",
+        caution_copy="Do not expose every path unless the user expands the evidence section.",
+        quiet_copy="Compress follow_up paths into one plain-language line.",
+        report_copy="Report follow_up only as a decision aid, not as proof of user intent.",
+    ),
+    EvidenceCompressionPattern(
+        pattern_id="epat_052_mentions",
+        relation="mentions",
+        bucket="supporting",
+        priority=8,
+        label="Mention context",
+        summary_template="{count} path(s) use mentions as the main evidence relation.",
+        reviewer_question="Does the mentions relation actually support the saved reason?",
+        missing_prompt="If this relation is missing, rely on the source text instead of graph proximity.",
+        support_copy="This relation can support a compact evidence statement.",
+        caution_copy="Do not expose every path unless the user expands the evidence section.",
+        quiet_copy="Compress mentions paths into one plain-language line.",
+        report_copy="Report mentions only as a decision aid, not as proof of user intent.",
+    ),
+    EvidenceCompressionPattern(
+        pattern_id="epat_053_contradicts",
+        relation="contradicts",
+        bucket="insufficient",
+        priority=9,
+        label="Potential conflict",
+        summary_template="{count} path(s) use contradicts as the main evidence relation.",
+        reviewer_question="Does the contradicts relation actually support the saved reason?",
+        missing_prompt="If this relation is missing, rely on the source text instead of graph proximity.",
+        support_copy="This relation can support a compact evidence statement.",
+        caution_copy="Do not expose every path unless the user expands the evidence section.",
+        quiet_copy="Compress contradicts paths into one plain-language line.",
+        report_copy="Report contradicts only as a decision aid, not as proof of user intent.",
+    ),
+    EvidenceCompressionPattern(
+        pattern_id="epat_054_derived_from",
+        relation="derived_from",
+        bucket="supporting",
+        priority=1,
+        label="Derived context",
+        summary_template="{count} path(s) use derived_from as the main evidence relation.",
+        reviewer_question="Does the derived_from relation actually support the saved reason?",
+        missing_prompt="If this relation is missing, rely on the source text instead of graph proximity.",
+        support_copy="This relation can support a compact evidence statement.",
+        caution_copy="Do not expose every path unless the user expands the evidence section.",
+        quiet_copy="Compress derived_from paths into one plain-language line.",
+        report_copy="Report derived_from only as a decision aid, not as proof of user intent.",
+    ),
+    EvidenceCompressionPattern(
+        pattern_id="epat_055_related_to",
+        relation="related_to",
+        bucket="needs_confirmation",
+        priority=2,
+        label="Weak relation",
+        summary_template="{count} path(s) use related_to as the main evidence relation.",
+        reviewer_question="Does the related_to relation actually support the saved reason?",
+        missing_prompt="If this relation is missing, rely on the source text instead of graph proximity.",
+        support_copy="This relation can support a compact evidence statement.",
+        caution_copy="Do not expose every path unless the user expands the evidence section.",
+        quiet_copy="Compress related_to paths into one plain-language line.",
+        report_copy="Report related_to only as a decision aid, not as proof of user intent.",
+    ),
+    EvidenceCompressionPattern(
+        pattern_id="epat_056_triggered_thought",
+        relation="triggered_thought",
+        bucket="supporting",
+        priority=3,
+        label="Saved reason path",
+        summary_template="{count} path(s) use triggered_thought as the main evidence relation.",
+        reviewer_question="Does the triggered_thought relation actually support the saved reason?",
+        missing_prompt="If this relation is missing, rely on the source text instead of graph proximity.",
+        support_copy="This relation can support a compact evidence statement.",
+        caution_copy="Do not expose every path unless the user expands the evidence section.",
+        quiet_copy="Compress triggered_thought paths into one plain-language line.",
+        report_copy="Report triggered_thought only as a decision aid, not as proof of user intent.",
+    ),
+    EvidenceCompressionPattern(
+        pattern_id="epat_057_evidence_for",
+        relation="evidence_for",
+        bucket="supporting",
+        priority=4,
+        label="Evidence support",
+        summary_template="{count} path(s) use evidence_for as the main evidence relation.",
+        reviewer_question="Does the evidence_for relation actually support the saved reason?",
+        missing_prompt="If this relation is missing, rely on the source text instead of graph proximity.",
+        support_copy="This relation can support a compact evidence statement.",
+        caution_copy="Do not expose every path unless the user expands the evidence section.",
+        quiet_copy="Compress evidence_for paths into one plain-language line.",
+        report_copy="Report evidence_for only as a decision aid, not as proof of user intent.",
+    ),
+    EvidenceCompressionPattern(
+        pattern_id="epat_058_belongs_to",
+        relation="belongs_to",
+        bucket="supporting",
+        priority=5,
+        label="Project connection",
+        summary_template="{count} path(s) use belongs_to as the main evidence relation.",
+        reviewer_question="Does the belongs_to relation actually support the saved reason?",
+        missing_prompt="If this relation is missing, rely on the source text instead of graph proximity.",
+        support_copy="This relation can support a compact evidence statement.",
+        caution_copy="Do not expose every path unless the user expands the evidence section.",
+        quiet_copy="Compress belongs_to paths into one plain-language line.",
+        report_copy="Report belongs_to only as a decision aid, not as proof of user intent.",
+    ),
+    EvidenceCompressionPattern(
+        pattern_id="epat_059_follow_up",
+        relation="follow_up",
+        bucket="needs_confirmation",
+        priority=6,
+        label="Open loop path",
+        summary_template="{count} path(s) use follow_up as the main evidence relation.",
+        reviewer_question="Does the follow_up relation actually support the saved reason?",
+        missing_prompt="If this relation is missing, rely on the source text instead of graph proximity.",
+        support_copy="This relation can support a compact evidence statement.",
+        caution_copy="Do not expose every path unless the user expands the evidence section.",
+        quiet_copy="Compress follow_up paths into one plain-language line.",
+        report_copy="Report follow_up only as a decision aid, not as proof of user intent.",
+    ),
+    EvidenceCompressionPattern(
+        pattern_id="epat_060_mentions",
+        relation="mentions",
+        bucket="supporting",
+        priority=7,
+        label="Mention context",
+        summary_template="{count} path(s) use mentions as the main evidence relation.",
+        reviewer_question="Does the mentions relation actually support the saved reason?",
+        missing_prompt="If this relation is missing, rely on the source text instead of graph proximity.",
+        support_copy="This relation can support a compact evidence statement.",
+        caution_copy="Do not expose every path unless the user expands the evidence section.",
+        quiet_copy="Compress mentions paths into one plain-language line.",
+        report_copy="Report mentions only as a decision aid, not as proof of user intent.",
+    ),
+    EvidenceCompressionPattern(
+        pattern_id="epat_061_contradicts",
+        relation="contradicts",
+        bucket="insufficient",
+        priority=8,
+        label="Potential conflict",
+        summary_template="{count} path(s) use contradicts as the main evidence relation.",
+        reviewer_question="Does the contradicts relation actually support the saved reason?",
+        missing_prompt="If this relation is missing, rely on the source text instead of graph proximity.",
+        support_copy="This relation can support a compact evidence statement.",
+        caution_copy="Do not expose every path unless the user expands the evidence section.",
+        quiet_copy="Compress contradicts paths into one plain-language line.",
+        report_copy="Report contradicts only as a decision aid, not as proof of user intent.",
+    ),
+    EvidenceCompressionPattern(
+        pattern_id="epat_062_derived_from",
+        relation="derived_from",
+        bucket="supporting",
+        priority=9,
+        label="Derived context",
+        summary_template="{count} path(s) use derived_from as the main evidence relation.",
+        reviewer_question="Does the derived_from relation actually support the saved reason?",
+        missing_prompt="If this relation is missing, rely on the source text instead of graph proximity.",
+        support_copy="This relation can support a compact evidence statement.",
+        caution_copy="Do not expose every path unless the user expands the evidence section.",
+        quiet_copy="Compress derived_from paths into one plain-language line.",
+        report_copy="Report derived_from only as a decision aid, not as proof of user intent.",
+    ),
+    EvidenceCompressionPattern(
+        pattern_id="epat_063_related_to",
+        relation="related_to",
+        bucket="needs_confirmation",
+        priority=1,
+        label="Weak relation",
+        summary_template="{count} path(s) use related_to as the main evidence relation.",
+        reviewer_question="Does the related_to relation actually support the saved reason?",
+        missing_prompt="If this relation is missing, rely on the source text instead of graph proximity.",
+        support_copy="This relation can support a compact evidence statement.",
+        caution_copy="Do not expose every path unless the user expands the evidence section.",
+        quiet_copy="Compress related_to paths into one plain-language line.",
+        report_copy="Report related_to only as a decision aid, not as proof of user intent.",
+    ),
+    EvidenceCompressionPattern(
+        pattern_id="epat_064_triggered_thought",
+        relation="triggered_thought",
+        bucket="supporting",
+        priority=2,
+        label="Saved reason path",
+        summary_template="{count} path(s) use triggered_thought as the main evidence relation.",
+        reviewer_question="Does the triggered_thought relation actually support the saved reason?",
+        missing_prompt="If this relation is missing, rely on the source text instead of graph proximity.",
+        support_copy="This relation can support a compact evidence statement.",
+        caution_copy="Do not expose every path unless the user expands the evidence section.",
+        quiet_copy="Compress triggered_thought paths into one plain-language line.",
+        report_copy="Report triggered_thought only as a decision aid, not as proof of user intent.",
+    ),
+    EvidenceCompressionPattern(
+        pattern_id="epat_065_evidence_for",
+        relation="evidence_for",
+        bucket="supporting",
+        priority=3,
+        label="Evidence support",
+        summary_template="{count} path(s) use evidence_for as the main evidence relation.",
+        reviewer_question="Does the evidence_for relation actually support the saved reason?",
+        missing_prompt="If this relation is missing, rely on the source text instead of graph proximity.",
+        support_copy="This relation can support a compact evidence statement.",
+        caution_copy="Do not expose every path unless the user expands the evidence section.",
+        quiet_copy="Compress evidence_for paths into one plain-language line.",
+        report_copy="Report evidence_for only as a decision aid, not as proof of user intent.",
+    ),
+    EvidenceCompressionPattern(
+        pattern_id="epat_066_belongs_to",
+        relation="belongs_to",
+        bucket="supporting",
+        priority=4,
+        label="Project connection",
+        summary_template="{count} path(s) use belongs_to as the main evidence relation.",
+        reviewer_question="Does the belongs_to relation actually support the saved reason?",
+        missing_prompt="If this relation is missing, rely on the source text instead of graph proximity.",
+        support_copy="This relation can support a compact evidence statement.",
+        caution_copy="Do not expose every path unless the user expands the evidence section.",
+        quiet_copy="Compress belongs_to paths into one plain-language line.",
+        report_copy="Report belongs_to only as a decision aid, not as proof of user intent.",
+    ),
+    EvidenceCompressionPattern(
+        pattern_id="epat_067_follow_up",
+        relation="follow_up",
+        bucket="needs_confirmation",
+        priority=5,
+        label="Open loop path",
+        summary_template="{count} path(s) use follow_up as the main evidence relation.",
+        reviewer_question="Does the follow_up relation actually support the saved reason?",
+        missing_prompt="If this relation is missing, rely on the source text instead of graph proximity.",
+        support_copy="This relation can support a compact evidence statement.",
+        caution_copy="Do not expose every path unless the user expands the evidence section.",
+        quiet_copy="Compress follow_up paths into one plain-language line.",
+        report_copy="Report follow_up only as a decision aid, not as proof of user intent.",
+    ),
+    EvidenceCompressionPattern(
+        pattern_id="epat_068_mentions",
+        relation="mentions",
+        bucket="supporting",
+        priority=6,
+        label="Mention context",
+        summary_template="{count} path(s) use mentions as the main evidence relation.",
+        reviewer_question="Does the mentions relation actually support the saved reason?",
+        missing_prompt="If this relation is missing, rely on the source text instead of graph proximity.",
+        support_copy="This relation can support a compact evidence statement.",
+        caution_copy="Do not expose every path unless the user expands the evidence section.",
+        quiet_copy="Compress mentions paths into one plain-language line.",
+        report_copy="Report mentions only as a decision aid, not as proof of user intent.",
+    ),
+    EvidenceCompressionPattern(
+        pattern_id="epat_069_contradicts",
+        relation="contradicts",
+        bucket="insufficient",
+        priority=7,
+        label="Potential conflict",
+        summary_template="{count} path(s) use contradicts as the main evidence relation.",
+        reviewer_question="Does the contradicts relation actually support the saved reason?",
+        missing_prompt="If this relation is missing, rely on the source text instead of graph proximity.",
+        support_copy="This relation can support a compact evidence statement.",
+        caution_copy="Do not expose every path unless the user expands the evidence section.",
+        quiet_copy="Compress contradicts paths into one plain-language line.",
+        report_copy="Report contradicts only as a decision aid, not as proof of user intent.",
+    ),
+    EvidenceCompressionPattern(
+        pattern_id="epat_070_derived_from",
+        relation="derived_from",
+        bucket="supporting",
+        priority=8,
+        label="Derived context",
+        summary_template="{count} path(s) use derived_from as the main evidence relation.",
+        reviewer_question="Does the derived_from relation actually support the saved reason?",
+        missing_prompt="If this relation is missing, rely on the source text instead of graph proximity.",
+        support_copy="This relation can support a compact evidence statement.",
+        caution_copy="Do not expose every path unless the user expands the evidence section.",
+        quiet_copy="Compress derived_from paths into one plain-language line.",
+        report_copy="Report derived_from only as a decision aid, not as proof of user intent.",
+    ),
+    EvidenceCompressionPattern(
+        pattern_id="epat_071_related_to",
+        relation="related_to",
+        bucket="needs_confirmation",
+        priority=9,
+        label="Weak relation",
+        summary_template="{count} path(s) use related_to as the main evidence relation.",
+        reviewer_question="Does the related_to relation actually support the saved reason?",
+        missing_prompt="If this relation is missing, rely on the source text instead of graph proximity.",
+        support_copy="This relation can support a compact evidence statement.",
+        caution_copy="Do not expose every path unless the user expands the evidence section.",
+        quiet_copy="Compress related_to paths into one plain-language line.",
+        report_copy="Report related_to only as a decision aid, not as proof of user intent.",
+    ),
+    EvidenceCompressionPattern(
+        pattern_id="epat_072_triggered_thought",
+        relation="triggered_thought",
+        bucket="supporting",
+        priority=1,
+        label="Saved reason path",
+        summary_template="{count} path(s) use triggered_thought as the main evidence relation.",
+        reviewer_question="Does the triggered_thought relation actually support the saved reason?",
+        missing_prompt="If this relation is missing, rely on the source text instead of graph proximity.",
+        support_copy="This relation can support a compact evidence statement.",
+        caution_copy="Do not expose every path unless the user expands the evidence section.",
+        quiet_copy="Compress triggered_thought paths into one plain-language line.",
+        report_copy="Report triggered_thought only as a decision aid, not as proof of user intent.",
+    ),
+    EvidenceCompressionPattern(
+        pattern_id="epat_073_evidence_for",
+        relation="evidence_for",
+        bucket="supporting",
+        priority=2,
+        label="Evidence support",
+        summary_template="{count} path(s) use evidence_for as the main evidence relation.",
+        reviewer_question="Does the evidence_for relation actually support the saved reason?",
+        missing_prompt="If this relation is missing, rely on the source text instead of graph proximity.",
+        support_copy="This relation can support a compact evidence statement.",
+        caution_copy="Do not expose every path unless the user expands the evidence section.",
+        quiet_copy="Compress evidence_for paths into one plain-language line.",
+        report_copy="Report evidence_for only as a decision aid, not as proof of user intent.",
+    ),
+    EvidenceCompressionPattern(
+        pattern_id="epat_074_belongs_to",
+        relation="belongs_to",
+        bucket="supporting",
+        priority=3,
+        label="Project connection",
+        summary_template="{count} path(s) use belongs_to as the main evidence relation.",
+        reviewer_question="Does the belongs_to relation actually support the saved reason?",
+        missing_prompt="If this relation is missing, rely on the source text instead of graph proximity.",
+        support_copy="This relation can support a compact evidence statement.",
+        caution_copy="Do not expose every path unless the user expands the evidence section.",
+        quiet_copy="Compress belongs_to paths into one plain-language line.",
+        report_copy="Report belongs_to only as a decision aid, not as proof of user intent.",
+    ),
+    EvidenceCompressionPattern(
+        pattern_id="epat_075_follow_up",
+        relation="follow_up",
+        bucket="needs_confirmation",
+        priority=4,
+        label="Open loop path",
+        summary_template="{count} path(s) use follow_up as the main evidence relation.",
+        reviewer_question="Does the follow_up relation actually support the saved reason?",
+        missing_prompt="If this relation is missing, rely on the source text instead of graph proximity.",
+        support_copy="This relation can support a compact evidence statement.",
+        caution_copy="Do not expose every path unless the user expands the evidence section.",
+        quiet_copy="Compress follow_up paths into one plain-language line.",
+        report_copy="Report follow_up only as a decision aid, not as proof of user intent.",
+    ),
+    EvidenceCompressionPattern(
+        pattern_id="epat_076_mentions",
+        relation="mentions",
+        bucket="supporting",
+        priority=5,
+        label="Mention context",
+        summary_template="{count} path(s) use mentions as the main evidence relation.",
+        reviewer_question="Does the mentions relation actually support the saved reason?",
+        missing_prompt="If this relation is missing, rely on the source text instead of graph proximity.",
+        support_copy="This relation can support a compact evidence statement.",
+        caution_copy="Do not expose every path unless the user expands the evidence section.",
+        quiet_copy="Compress mentions paths into one plain-language line.",
+        report_copy="Report mentions only as a decision aid, not as proof of user intent.",
+    ),
+    EvidenceCompressionPattern(
+        pattern_id="epat_077_contradicts",
+        relation="contradicts",
+        bucket="insufficient",
+        priority=6,
+        label="Potential conflict",
+        summary_template="{count} path(s) use contradicts as the main evidence relation.",
+        reviewer_question="Does the contradicts relation actually support the saved reason?",
+        missing_prompt="If this relation is missing, rely on the source text instead of graph proximity.",
+        support_copy="This relation can support a compact evidence statement.",
+        caution_copy="Do not expose every path unless the user expands the evidence section.",
+        quiet_copy="Compress contradicts paths into one plain-language line.",
+        report_copy="Report contradicts only as a decision aid, not as proof of user intent.",
+    ),
+    EvidenceCompressionPattern(
+        pattern_id="epat_078_derived_from",
+        relation="derived_from",
+        bucket="supporting",
+        priority=7,
+        label="Derived context",
+        summary_template="{count} path(s) use derived_from as the main evidence relation.",
+        reviewer_question="Does the derived_from relation actually support the saved reason?",
+        missing_prompt="If this relation is missing, rely on the source text instead of graph proximity.",
+        support_copy="This relation can support a compact evidence statement.",
+        caution_copy="Do not expose every path unless the user expands the evidence section.",
+        quiet_copy="Compress derived_from paths into one plain-language line.",
+        report_copy="Report derived_from only as a decision aid, not as proof of user intent.",
+    ),
+    EvidenceCompressionPattern(
+        pattern_id="epat_079_related_to",
+        relation="related_to",
+        bucket="needs_confirmation",
+        priority=8,
+        label="Weak relation",
+        summary_template="{count} path(s) use related_to as the main evidence relation.",
+        reviewer_question="Does the related_to relation actually support the saved reason?",
+        missing_prompt="If this relation is missing, rely on the source text instead of graph proximity.",
+        support_copy="This relation can support a compact evidence statement.",
+        caution_copy="Do not expose every path unless the user expands the evidence section.",
+        quiet_copy="Compress related_to paths into one plain-language line.",
+        report_copy="Report related_to only as a decision aid, not as proof of user intent.",
+    ),
+    EvidenceCompressionPattern(
+        pattern_id="epat_080_triggered_thought",
+        relation="triggered_thought",
+        bucket="supporting",
+        priority=9,
+        label="Saved reason path",
+        summary_template="{count} path(s) use triggered_thought as the main evidence relation.",
+        reviewer_question="Does the triggered_thought relation actually support the saved reason?",
+        missing_prompt="If this relation is missing, rely on the source text instead of graph proximity.",
+        support_copy="This relation can support a compact evidence statement.",
+        caution_copy="Do not expose every path unless the user expands the evidence section.",
+        quiet_copy="Compress triggered_thought paths into one plain-language line.",
+        report_copy="Report triggered_thought only as a decision aid, not as proof of user intent.",
+    ),
+    EvidenceCompressionPattern(
+        pattern_id="epat_081_evidence_for",
+        relation="evidence_for",
+        bucket="supporting",
+        priority=1,
+        label="Evidence support",
+        summary_template="{count} path(s) use evidence_for as the main evidence relation.",
+        reviewer_question="Does the evidence_for relation actually support the saved reason?",
+        missing_prompt="If this relation is missing, rely on the source text instead of graph proximity.",
+        support_copy="This relation can support a compact evidence statement.",
+        caution_copy="Do not expose every path unless the user expands the evidence section.",
+        quiet_copy="Compress evidence_for paths into one plain-language line.",
+        report_copy="Report evidence_for only as a decision aid, not as proof of user intent.",
+    ),
+    EvidenceCompressionPattern(
+        pattern_id="epat_082_belongs_to",
+        relation="belongs_to",
+        bucket="supporting",
+        priority=2,
+        label="Project connection",
+        summary_template="{count} path(s) use belongs_to as the main evidence relation.",
+        reviewer_question="Does the belongs_to relation actually support the saved reason?",
+        missing_prompt="If this relation is missing, rely on the source text instead of graph proximity.",
+        support_copy="This relation can support a compact evidence statement.",
+        caution_copy="Do not expose every path unless the user expands the evidence section.",
+        quiet_copy="Compress belongs_to paths into one plain-language line.",
+        report_copy="Report belongs_to only as a decision aid, not as proof of user intent.",
+    ),
+    EvidenceCompressionPattern(
+        pattern_id="epat_083_follow_up",
+        relation="follow_up",
+        bucket="needs_confirmation",
+        priority=3,
+        label="Open loop path",
+        summary_template="{count} path(s) use follow_up as the main evidence relation.",
+        reviewer_question="Does the follow_up relation actually support the saved reason?",
+        missing_prompt="If this relation is missing, rely on the source text instead of graph proximity.",
+        support_copy="This relation can support a compact evidence statement.",
+        caution_copy="Do not expose every path unless the user expands the evidence section.",
+        quiet_copy="Compress follow_up paths into one plain-language line.",
+        report_copy="Report follow_up only as a decision aid, not as proof of user intent.",
+    ),
+    EvidenceCompressionPattern(
+        pattern_id="epat_084_mentions",
+        relation="mentions",
+        bucket="supporting",
+        priority=4,
+        label="Mention context",
+        summary_template="{count} path(s) use mentions as the main evidence relation.",
+        reviewer_question="Does the mentions relation actually support the saved reason?",
+        missing_prompt="If this relation is missing, rely on the source text instead of graph proximity.",
+        support_copy="This relation can support a compact evidence statement.",
+        caution_copy="Do not expose every path unless the user expands the evidence section.",
+        quiet_copy="Compress mentions paths into one plain-language line.",
+        report_copy="Report mentions only as a decision aid, not as proof of user intent.",
+    ),
+    EvidenceCompressionPattern(
+        pattern_id="epat_085_contradicts",
+        relation="contradicts",
+        bucket="insufficient",
+        priority=5,
+        label="Potential conflict",
+        summary_template="{count} path(s) use contradicts as the main evidence relation.",
+        reviewer_question="Does the contradicts relation actually support the saved reason?",
+        missing_prompt="If this relation is missing, rely on the source text instead of graph proximity.",
+        support_copy="This relation can support a compact evidence statement.",
+        caution_copy="Do not expose every path unless the user expands the evidence section.",
+        quiet_copy="Compress contradicts paths into one plain-language line.",
+        report_copy="Report contradicts only as a decision aid, not as proof of user intent.",
+    ),
+    EvidenceCompressionPattern(
+        pattern_id="epat_086_derived_from",
+        relation="derived_from",
+        bucket="supporting",
+        priority=6,
+        label="Derived context",
+        summary_template="{count} path(s) use derived_from as the main evidence relation.",
+        reviewer_question="Does the derived_from relation actually support the saved reason?",
+        missing_prompt="If this relation is missing, rely on the source text instead of graph proximity.",
+        support_copy="This relation can support a compact evidence statement.",
+        caution_copy="Do not expose every path unless the user expands the evidence section.",
+        quiet_copy="Compress derived_from paths into one plain-language line.",
+        report_copy="Report derived_from only as a decision aid, not as proof of user intent.",
+    ),
+    EvidenceCompressionPattern(
+        pattern_id="epat_087_related_to",
+        relation="related_to",
+        bucket="needs_confirmation",
+        priority=7,
+        label="Weak relation",
+        summary_template="{count} path(s) use related_to as the main evidence relation.",
+        reviewer_question="Does the related_to relation actually support the saved reason?",
+        missing_prompt="If this relation is missing, rely on the source text instead of graph proximity.",
+        support_copy="This relation can support a compact evidence statement.",
+        caution_copy="Do not expose every path unless the user expands the evidence section.",
+        quiet_copy="Compress related_to paths into one plain-language line.",
+        report_copy="Report related_to only as a decision aid, not as proof of user intent.",
+    ),
+    EvidenceCompressionPattern(
+        pattern_id="epat_088_triggered_thought",
+        relation="triggered_thought",
+        bucket="supporting",
+        priority=8,
+        label="Saved reason path",
+        summary_template="{count} path(s) use triggered_thought as the main evidence relation.",
+        reviewer_question="Does the triggered_thought relation actually support the saved reason?",
+        missing_prompt="If this relation is missing, rely on the source text instead of graph proximity.",
+        support_copy="This relation can support a compact evidence statement.",
+        caution_copy="Do not expose every path unless the user expands the evidence section.",
+        quiet_copy="Compress triggered_thought paths into one plain-language line.",
+        report_copy="Report triggered_thought only as a decision aid, not as proof of user intent.",
+    ),
+    EvidenceCompressionPattern(
+        pattern_id="epat_089_evidence_for",
+        relation="evidence_for",
+        bucket="supporting",
+        priority=9,
+        label="Evidence support",
+        summary_template="{count} path(s) use evidence_for as the main evidence relation.",
+        reviewer_question="Does the evidence_for relation actually support the saved reason?",
+        missing_prompt="If this relation is missing, rely on the source text instead of graph proximity.",
+        support_copy="This relation can support a compact evidence statement.",
+        caution_copy="Do not expose every path unless the user expands the evidence section.",
+        quiet_copy="Compress evidence_for paths into one plain-language line.",
+        report_copy="Report evidence_for only as a decision aid, not as proof of user intent.",
+    ),
+    EvidenceCompressionPattern(
+        pattern_id="epat_090_belongs_to",
+        relation="belongs_to",
+        bucket="supporting",
+        priority=1,
+        label="Project connection",
+        summary_template="{count} path(s) use belongs_to as the main evidence relation.",
+        reviewer_question="Does the belongs_to relation actually support the saved reason?",
+        missing_prompt="If this relation is missing, rely on the source text instead of graph proximity.",
+        support_copy="This relation can support a compact evidence statement.",
+        caution_copy="Do not expose every path unless the user expands the evidence section.",
+        quiet_copy="Compress belongs_to paths into one plain-language line.",
+        report_copy="Report belongs_to only as a decision aid, not as proof of user intent.",
+    ),
+    EvidenceCompressionPattern(
+        pattern_id="epat_091_follow_up",
+        relation="follow_up",
+        bucket="needs_confirmation",
+        priority=2,
+        label="Open loop path",
+        summary_template="{count} path(s) use follow_up as the main evidence relation.",
+        reviewer_question="Does the follow_up relation actually support the saved reason?",
+        missing_prompt="If this relation is missing, rely on the source text instead of graph proximity.",
+        support_copy="This relation can support a compact evidence statement.",
+        caution_copy="Do not expose every path unless the user expands the evidence section.",
+        quiet_copy="Compress follow_up paths into one plain-language line.",
+        report_copy="Report follow_up only as a decision aid, not as proof of user intent.",
+    ),
+    EvidenceCompressionPattern(
+        pattern_id="epat_092_mentions",
+        relation="mentions",
+        bucket="supporting",
+        priority=3,
+        label="Mention context",
+        summary_template="{count} path(s) use mentions as the main evidence relation.",
+        reviewer_question="Does the mentions relation actually support the saved reason?",
+        missing_prompt="If this relation is missing, rely on the source text instead of graph proximity.",
+        support_copy="This relation can support a compact evidence statement.",
+        caution_copy="Do not expose every path unless the user expands the evidence section.",
+        quiet_copy="Compress mentions paths into one plain-language line.",
+        report_copy="Report mentions only as a decision aid, not as proof of user intent.",
+    ),
+    EvidenceCompressionPattern(
+        pattern_id="epat_093_contradicts",
+        relation="contradicts",
+        bucket="insufficient",
+        priority=4,
+        label="Potential conflict",
+        summary_template="{count} path(s) use contradicts as the main evidence relation.",
+        reviewer_question="Does the contradicts relation actually support the saved reason?",
+        missing_prompt="If this relation is missing, rely on the source text instead of graph proximity.",
+        support_copy="This relation can support a compact evidence statement.",
+        caution_copy="Do not expose every path unless the user expands the evidence section.",
+        quiet_copy="Compress contradicts paths into one plain-language line.",
+        report_copy="Report contradicts only as a decision aid, not as proof of user intent.",
+    ),
+    EvidenceCompressionPattern(
+        pattern_id="epat_094_derived_from",
+        relation="derived_from",
+        bucket="supporting",
+        priority=5,
+        label="Derived context",
+        summary_template="{count} path(s) use derived_from as the main evidence relation.",
+        reviewer_question="Does the derived_from relation actually support the saved reason?",
+        missing_prompt="If this relation is missing, rely on the source text instead of graph proximity.",
+        support_copy="This relation can support a compact evidence statement.",
+        caution_copy="Do not expose every path unless the user expands the evidence section.",
+        quiet_copy="Compress derived_from paths into one plain-language line.",
+        report_copy="Report derived_from only as a decision aid, not as proof of user intent.",
+    ),
+    EvidenceCompressionPattern(
+        pattern_id="epat_095_related_to",
+        relation="related_to",
+        bucket="needs_confirmation",
+        priority=6,
+        label="Weak relation",
+        summary_template="{count} path(s) use related_to as the main evidence relation.",
+        reviewer_question="Does the related_to relation actually support the saved reason?",
+        missing_prompt="If this relation is missing, rely on the source text instead of graph proximity.",
+        support_copy="This relation can support a compact evidence statement.",
+        caution_copy="Do not expose every path unless the user expands the evidence section.",
+        quiet_copy="Compress related_to paths into one plain-language line.",
+        report_copy="Report related_to only as a decision aid, not as proof of user intent.",
+    ),
+    EvidenceCompressionPattern(
+        pattern_id="epat_096_triggered_thought",
+        relation="triggered_thought",
+        bucket="supporting",
+        priority=7,
+        label="Saved reason path",
+        summary_template="{count} path(s) use triggered_thought as the main evidence relation.",
+        reviewer_question="Does the triggered_thought relation actually support the saved reason?",
+        missing_prompt="If this relation is missing, rely on the source text instead of graph proximity.",
+        support_copy="This relation can support a compact evidence statement.",
+        caution_copy="Do not expose every path unless the user expands the evidence section.",
+        quiet_copy="Compress triggered_thought paths into one plain-language line.",
+        report_copy="Report triggered_thought only as a decision aid, not as proof of user intent.",
+    ),
+    EvidenceCompressionPattern(
+        pattern_id="epat_097_evidence_for",
+        relation="evidence_for",
+        bucket="supporting",
+        priority=8,
+        label="Evidence support",
+        summary_template="{count} path(s) use evidence_for as the main evidence relation.",
+        reviewer_question="Does the evidence_for relation actually support the saved reason?",
+        missing_prompt="If this relation is missing, rely on the source text instead of graph proximity.",
+        support_copy="This relation can support a compact evidence statement.",
+        caution_copy="Do not expose every path unless the user expands the evidence section.",
+        quiet_copy="Compress evidence_for paths into one plain-language line.",
+        report_copy="Report evidence_for only as a decision aid, not as proof of user intent.",
+    ),
+    EvidenceCompressionPattern(
+        pattern_id="epat_098_belongs_to",
+        relation="belongs_to",
+        bucket="supporting",
+        priority=9,
+        label="Project connection",
+        summary_template="{count} path(s) use belongs_to as the main evidence relation.",
+        reviewer_question="Does the belongs_to relation actually support the saved reason?",
+        missing_prompt="If this relation is missing, rely on the source text instead of graph proximity.",
+        support_copy="This relation can support a compact evidence statement.",
+        caution_copy="Do not expose every path unless the user expands the evidence section.",
+        quiet_copy="Compress belongs_to paths into one plain-language line.",
+        report_copy="Report belongs_to only as a decision aid, not as proof of user intent.",
+    ),
+    EvidenceCompressionPattern(
+        pattern_id="epat_099_follow_up",
+        relation="follow_up",
+        bucket="needs_confirmation",
+        priority=1,
+        label="Open loop path",
+        summary_template="{count} path(s) use follow_up as the main evidence relation.",
+        reviewer_question="Does the follow_up relation actually support the saved reason?",
+        missing_prompt="If this relation is missing, rely on the source text instead of graph proximity.",
+        support_copy="This relation can support a compact evidence statement.",
+        caution_copy="Do not expose every path unless the user expands the evidence section.",
+        quiet_copy="Compress follow_up paths into one plain-language line.",
+        report_copy="Report follow_up only as a decision aid, not as proof of user intent.",
+    ),
+    EvidenceCompressionPattern(
+        pattern_id="epat_100_mentions",
+        relation="mentions",
+        bucket="supporting",
+        priority=2,
+        label="Mention context",
+        summary_template="{count} path(s) use mentions as the main evidence relation.",
+        reviewer_question="Does the mentions relation actually support the saved reason?",
+        missing_prompt="If this relation is missing, rely on the source text instead of graph proximity.",
+        support_copy="This relation can support a compact evidence statement.",
+        caution_copy="Do not expose every path unless the user expands the evidence section.",
+        quiet_copy="Compress mentions paths into one plain-language line.",
+        report_copy="Report mentions only as a decision aid, not as proof of user intent.",
+    ),
+    EvidenceCompressionPattern(
+        pattern_id="epat_101_contradicts",
+        relation="contradicts",
+        bucket="insufficient",
+        priority=3,
+        label="Potential conflict",
+        summary_template="{count} path(s) use contradicts as the main evidence relation.",
+        reviewer_question="Does the contradicts relation actually support the saved reason?",
+        missing_prompt="If this relation is missing, rely on the source text instead of graph proximity.",
+        support_copy="This relation can support a compact evidence statement.",
+        caution_copy="Do not expose every path unless the user expands the evidence section.",
+        quiet_copy="Compress contradicts paths into one plain-language line.",
+        report_copy="Report contradicts only as a decision aid, not as proof of user intent.",
+    ),
+    EvidenceCompressionPattern(
+        pattern_id="epat_102_derived_from",
+        relation="derived_from",
+        bucket="supporting",
+        priority=4,
+        label="Derived context",
+        summary_template="{count} path(s) use derived_from as the main evidence relation.",
+        reviewer_question="Does the derived_from relation actually support the saved reason?",
+        missing_prompt="If this relation is missing, rely on the source text instead of graph proximity.",
+        support_copy="This relation can support a compact evidence statement.",
+        caution_copy="Do not expose every path unless the user expands the evidence section.",
+        quiet_copy="Compress derived_from paths into one plain-language line.",
+        report_copy="Report derived_from only as a decision aid, not as proof of user intent.",
+    ),
+    EvidenceCompressionPattern(
+        pattern_id="epat_103_related_to",
+        relation="related_to",
+        bucket="needs_confirmation",
+        priority=5,
+        label="Weak relation",
+        summary_template="{count} path(s) use related_to as the main evidence relation.",
+        reviewer_question="Does the related_to relation actually support the saved reason?",
+        missing_prompt="If this relation is missing, rely on the source text instead of graph proximity.",
+        support_copy="This relation can support a compact evidence statement.",
+        caution_copy="Do not expose every path unless the user expands the evidence section.",
+        quiet_copy="Compress related_to paths into one plain-language line.",
+        report_copy="Report related_to only as a decision aid, not as proof of user intent.",
+    ),
+    EvidenceCompressionPattern(
+        pattern_id="epat_104_triggered_thought",
+        relation="triggered_thought",
+        bucket="supporting",
+        priority=6,
+        label="Saved reason path",
+        summary_template="{count} path(s) use triggered_thought as the main evidence relation.",
+        reviewer_question="Does the triggered_thought relation actually support the saved reason?",
+        missing_prompt="If this relation is missing, rely on the source text instead of graph proximity.",
+        support_copy="This relation can support a compact evidence statement.",
+        caution_copy="Do not expose every path unless the user expands the evidence section.",
+        quiet_copy="Compress triggered_thought paths into one plain-language line.",
+        report_copy="Report triggered_thought only as a decision aid, not as proof of user intent.",
+    ),
+    EvidenceCompressionPattern(
+        pattern_id="epat_105_evidence_for",
+        relation="evidence_for",
+        bucket="supporting",
+        priority=7,
+        label="Evidence support",
+        summary_template="{count} path(s) use evidence_for as the main evidence relation.",
+        reviewer_question="Does the evidence_for relation actually support the saved reason?",
+        missing_prompt="If this relation is missing, rely on the source text instead of graph proximity.",
+        support_copy="This relation can support a compact evidence statement.",
+        caution_copy="Do not expose every path unless the user expands the evidence section.",
+        quiet_copy="Compress evidence_for paths into one plain-language line.",
+        report_copy="Report evidence_for only as a decision aid, not as proof of user intent.",
+    ),
+    EvidenceCompressionPattern(
+        pattern_id="epat_106_belongs_to",
+        relation="belongs_to",
+        bucket="supporting",
+        priority=8,
+        label="Project connection",
+        summary_template="{count} path(s) use belongs_to as the main evidence relation.",
+        reviewer_question="Does the belongs_to relation actually support the saved reason?",
+        missing_prompt="If this relation is missing, rely on the source text instead of graph proximity.",
+        support_copy="This relation can support a compact evidence statement.",
+        caution_copy="Do not expose every path unless the user expands the evidence section.",
+        quiet_copy="Compress belongs_to paths into one plain-language line.",
+        report_copy="Report belongs_to only as a decision aid, not as proof of user intent.",
+    ),
+    EvidenceCompressionPattern(
+        pattern_id="epat_107_follow_up",
+        relation="follow_up",
+        bucket="needs_confirmation",
+        priority=9,
+        label="Open loop path",
+        summary_template="{count} path(s) use follow_up as the main evidence relation.",
+        reviewer_question="Does the follow_up relation actually support the saved reason?",
+        missing_prompt="If this relation is missing, rely on the source text instead of graph proximity.",
+        support_copy="This relation can support a compact evidence statement.",
+        caution_copy="Do not expose every path unless the user expands the evidence section.",
+        quiet_copy="Compress follow_up paths into one plain-language line.",
+        report_copy="Report follow_up only as a decision aid, not as proof of user intent.",
+    ),
+    EvidenceCompressionPattern(
+        pattern_id="epat_108_mentions",
+        relation="mentions",
+        bucket="supporting",
+        priority=1,
+        label="Mention context",
+        summary_template="{count} path(s) use mentions as the main evidence relation.",
+        reviewer_question="Does the mentions relation actually support the saved reason?",
+        missing_prompt="If this relation is missing, rely on the source text instead of graph proximity.",
+        support_copy="This relation can support a compact evidence statement.",
+        caution_copy="Do not expose every path unless the user expands the evidence section.",
+        quiet_copy="Compress mentions paths into one plain-language line.",
+        report_copy="Report mentions only as a decision aid, not as proof of user intent.",
+    ),
+    EvidenceCompressionPattern(
+        pattern_id="epat_109_contradicts",
+        relation="contradicts",
+        bucket="insufficient",
+        priority=2,
+        label="Potential conflict",
+        summary_template="{count} path(s) use contradicts as the main evidence relation.",
+        reviewer_question="Does the contradicts relation actually support the saved reason?",
+        missing_prompt="If this relation is missing, rely on the source text instead of graph proximity.",
+        support_copy="This relation can support a compact evidence statement.",
+        caution_copy="Do not expose every path unless the user expands the evidence section.",
+        quiet_copy="Compress contradicts paths into one plain-language line.",
+        report_copy="Report contradicts only as a decision aid, not as proof of user intent.",
+    ),
+    EvidenceCompressionPattern(
+        pattern_id="epat_110_derived_from",
+        relation="derived_from",
+        bucket="supporting",
+        priority=3,
+        label="Derived context",
+        summary_template="{count} path(s) use derived_from as the main evidence relation.",
+        reviewer_question="Does the derived_from relation actually support the saved reason?",
+        missing_prompt="If this relation is missing, rely on the source text instead of graph proximity.",
+        support_copy="This relation can support a compact evidence statement.",
+        caution_copy="Do not expose every path unless the user expands the evidence section.",
+        quiet_copy="Compress derived_from paths into one plain-language line.",
+        report_copy="Report derived_from only as a decision aid, not as proof of user intent.",
+    ),
+    EvidenceCompressionPattern(
+        pattern_id="epat_111_related_to",
+        relation="related_to",
+        bucket="needs_confirmation",
+        priority=4,
+        label="Weak relation",
+        summary_template="{count} path(s) use related_to as the main evidence relation.",
+        reviewer_question="Does the related_to relation actually support the saved reason?",
+        missing_prompt="If this relation is missing, rely on the source text instead of graph proximity.",
+        support_copy="This relation can support a compact evidence statement.",
+        caution_copy="Do not expose every path unless the user expands the evidence section.",
+        quiet_copy="Compress related_to paths into one plain-language line.",
+        report_copy="Report related_to only as a decision aid, not as proof of user intent.",
+    ),
+    EvidenceCompressionPattern(
+        pattern_id="epat_112_triggered_thought",
+        relation="triggered_thought",
+        bucket="supporting",
+        priority=5,
+        label="Saved reason path",
+        summary_template="{count} path(s) use triggered_thought as the main evidence relation.",
+        reviewer_question="Does the triggered_thought relation actually support the saved reason?",
+        missing_prompt="If this relation is missing, rely on the source text instead of graph proximity.",
+        support_copy="This relation can support a compact evidence statement.",
+        caution_copy="Do not expose every path unless the user expands the evidence section.",
+        quiet_copy="Compress triggered_thought paths into one plain-language line.",
+        report_copy="Report triggered_thought only as a decision aid, not as proof of user intent.",
+    ),
+    EvidenceCompressionPattern(
+        pattern_id="epat_113_evidence_for",
+        relation="evidence_for",
+        bucket="supporting",
+        priority=6,
+        label="Evidence support",
+        summary_template="{count} path(s) use evidence_for as the main evidence relation.",
+        reviewer_question="Does the evidence_for relation actually support the saved reason?",
+        missing_prompt="If this relation is missing, rely on the source text instead of graph proximity.",
+        support_copy="This relation can support a compact evidence statement.",
+        caution_copy="Do not expose every path unless the user expands the evidence section.",
+        quiet_copy="Compress evidence_for paths into one plain-language line.",
+        report_copy="Report evidence_for only as a decision aid, not as proof of user intent.",
+    ),
+    EvidenceCompressionPattern(
+        pattern_id="epat_114_belongs_to",
+        relation="belongs_to",
+        bucket="supporting",
+        priority=7,
+        label="Project connection",
+        summary_template="{count} path(s) use belongs_to as the main evidence relation.",
+        reviewer_question="Does the belongs_to relation actually support the saved reason?",
+        missing_prompt="If this relation is missing, rely on the source text instead of graph proximity.",
+        support_copy="This relation can support a compact evidence statement.",
+        caution_copy="Do not expose every path unless the user expands the evidence section.",
+        quiet_copy="Compress belongs_to paths into one plain-language line.",
+        report_copy="Report belongs_to only as a decision aid, not as proof of user intent.",
+    ),
+    EvidenceCompressionPattern(
+        pattern_id="epat_115_follow_up",
+        relation="follow_up",
+        bucket="needs_confirmation",
+        priority=8,
+        label="Open loop path",
+        summary_template="{count} path(s) use follow_up as the main evidence relation.",
+        reviewer_question="Does the follow_up relation actually support the saved reason?",
+        missing_prompt="If this relation is missing, rely on the source text instead of graph proximity.",
+        support_copy="This relation can support a compact evidence statement.",
+        caution_copy="Do not expose every path unless the user expands the evidence section.",
+        quiet_copy="Compress follow_up paths into one plain-language line.",
+        report_copy="Report follow_up only as a decision aid, not as proof of user intent.",
+    ),
+    EvidenceCompressionPattern(
+        pattern_id="epat_116_mentions",
+        relation="mentions",
+        bucket="supporting",
+        priority=9,
+        label="Mention context",
+        summary_template="{count} path(s) use mentions as the main evidence relation.",
+        reviewer_question="Does the mentions relation actually support the saved reason?",
+        missing_prompt="If this relation is missing, rely on the source text instead of graph proximity.",
+        support_copy="This relation can support a compact evidence statement.",
+        caution_copy="Do not expose every path unless the user expands the evidence section.",
+        quiet_copy="Compress mentions paths into one plain-language line.",
+        report_copy="Report mentions only as a decision aid, not as proof of user intent.",
+    ),
+    EvidenceCompressionPattern(
+        pattern_id="epat_117_contradicts",
+        relation="contradicts",
+        bucket="insufficient",
+        priority=1,
+        label="Potential conflict",
+        summary_template="{count} path(s) use contradicts as the main evidence relation.",
+        reviewer_question="Does the contradicts relation actually support the saved reason?",
+        missing_prompt="If this relation is missing, rely on the source text instead of graph proximity.",
+        support_copy="This relation can support a compact evidence statement.",
+        caution_copy="Do not expose every path unless the user expands the evidence section.",
+        quiet_copy="Compress contradicts paths into one plain-language line.",
+        report_copy="Report contradicts only as a decision aid, not as proof of user intent.",
+    ),
+    EvidenceCompressionPattern(
+        pattern_id="epat_118_derived_from",
+        relation="derived_from",
+        bucket="supporting",
+        priority=2,
+        label="Derived context",
+        summary_template="{count} path(s) use derived_from as the main evidence relation.",
+        reviewer_question="Does the derived_from relation actually support the saved reason?",
+        missing_prompt="If this relation is missing, rely on the source text instead of graph proximity.",
+        support_copy="This relation can support a compact evidence statement.",
+        caution_copy="Do not expose every path unless the user expands the evidence section.",
+        quiet_copy="Compress derived_from paths into one plain-language line.",
+        report_copy="Report derived_from only as a decision aid, not as proof of user intent.",
+    ),
+    EvidenceCompressionPattern(
+        pattern_id="epat_119_related_to",
+        relation="related_to",
+        bucket="needs_confirmation",
+        priority=3,
+        label="Weak relation",
+        summary_template="{count} path(s) use related_to as the main evidence relation.",
+        reviewer_question="Does the related_to relation actually support the saved reason?",
+        missing_prompt="If this relation is missing, rely on the source text instead of graph proximity.",
+        support_copy="This relation can support a compact evidence statement.",
+        caution_copy="Do not expose every path unless the user expands the evidence section.",
+        quiet_copy="Compress related_to paths into one plain-language line.",
+        report_copy="Report related_to only as a decision aid, not as proof of user intent.",
+    ),
+)
+
+DECISION_IMPACT_DEFINITIONS: tuple[DecisionImpactDefinition, ...] = (
+    DecisionImpactDefinition(
+        impact_id="impact_000_confirmed",
+        action="confirmed",
+        title="Confirmed decision impact",
+        tone="positive",
+        summary_template="Choosing confirmed changes how this reason can support future recall.",
+        recall_effect="Future answers will treat this source according to the confirmed decision.",
+        graph_effect="The graph keeps traceability while the trust status changes to confirmed.",
+        open_loop_effect="Open loops are preserved unless the user separately resolves them.",
+        user_pressure="Keep this preview to one sentence by default.",
+        warnings=("Only confirm when the saved reason matches user intent.",),
+        confirmation_question="Is confirmed the decision the user would stand behind later?",
+        next_step="Apply confirmed only after the evidence summary is readable.",
+    ),
+    DecisionImpactDefinition(
+        impact_id="impact_001_rewritten",
+        action="rewritten",
+        title="Rewritten decision impact",
+        tone="constructive",
+        summary_template="Choosing rewritten changes how this reason can support future recall.",
+        recall_effect="Future answers will treat this source according to the rewritten decision.",
+        graph_effect="The graph keeps traceability while the trust status changes to rewritten.",
+        open_loop_effect="Open loops are preserved unless the user separately resolves them.",
+        user_pressure="Keep this preview to one sentence by default.",
+        warnings=("Rewrite should replace the reason without deleting traceability.",),
+        confirmation_question="Is rewritten the decision the user would stand behind later?",
+        next_step="Apply rewritten only after the evidence summary is readable.",
+    ),
+    DecisionImpactDefinition(
+        impact_id="impact_002_rejected",
+        action="rejected",
+        title="Rejected decision impact",
+        tone="danger",
+        summary_template="Choosing rejected changes how this reason can support future recall.",
+        recall_effect="Future answers will treat this source according to the rejected decision.",
+        graph_effect="The graph keeps traceability while the trust status changes to rejected.",
+        open_loop_effect="Open loops are preserved unless the user separately resolves them.",
+        user_pressure="Keep this preview to one sentence by default.",
+        warnings=("Rejected context should not be reused as a trusted reason.",),
+        confirmation_question="Is rejected the decision the user would stand behind later?",
+        next_step="Apply rejected only after the evidence summary is readable.",
+    ),
+    DecisionImpactDefinition(
+        impact_id="impact_003_deferred",
+        action="deferred",
+        title="Deferred decision impact",
+        tone="neutral",
+        summary_template="Choosing deferred changes how this reason can support future recall.",
+        recall_effect="Future answers will treat this source according to the deferred decision.",
+        graph_effect="The graph keeps traceability while the trust status changes to deferred.",
+        open_loop_effect="Open loops are preserved unless the user separately resolves them.",
+        user_pressure="Keep this preview to one sentence by default.",
+        warnings=("Deferred items remain visible in future review sessions.",),
+        confirmation_question="Is deferred the decision the user would stand behind later?",
+        next_step="Apply deferred only after the evidence summary is readable.",
+    ),
+    DecisionImpactDefinition(
+        impact_id="impact_004_confirmed",
+        action="confirmed",
+        title="Confirmed decision impact",
+        tone="positive",
+        summary_template="Choosing confirmed changes how this reason can support future recall.",
+        recall_effect="Future answers will treat this source according to the confirmed decision.",
+        graph_effect="The graph keeps traceability while the trust status changes to confirmed.",
+        open_loop_effect="Open loops are preserved unless the user separately resolves them.",
+        user_pressure="Keep this preview to one sentence by default.",
+        warnings=("Only confirm when the saved reason matches user intent.",),
+        confirmation_question="Is confirmed the decision the user would stand behind later?",
+        next_step="Apply confirmed only after the evidence summary is readable.",
+    ),
+    DecisionImpactDefinition(
+        impact_id="impact_005_rewritten",
+        action="rewritten",
+        title="Rewritten decision impact",
+        tone="constructive",
+        summary_template="Choosing rewritten changes how this reason can support future recall.",
+        recall_effect="Future answers will treat this source according to the rewritten decision.",
+        graph_effect="The graph keeps traceability while the trust status changes to rewritten.",
+        open_loop_effect="Open loops are preserved unless the user separately resolves them.",
+        user_pressure="Keep this preview to one sentence by default.",
+        warnings=("Rewrite should replace the reason without deleting traceability.",),
+        confirmation_question="Is rewritten the decision the user would stand behind later?",
+        next_step="Apply rewritten only after the evidence summary is readable.",
+    ),
+    DecisionImpactDefinition(
+        impact_id="impact_006_rejected",
+        action="rejected",
+        title="Rejected decision impact",
+        tone="danger",
+        summary_template="Choosing rejected changes how this reason can support future recall.",
+        recall_effect="Future answers will treat this source according to the rejected decision.",
+        graph_effect="The graph keeps traceability while the trust status changes to rejected.",
+        open_loop_effect="Open loops are preserved unless the user separately resolves them.",
+        user_pressure="Keep this preview to one sentence by default.",
+        warnings=("Rejected context should not be reused as a trusted reason.",),
+        confirmation_question="Is rejected the decision the user would stand behind later?",
+        next_step="Apply rejected only after the evidence summary is readable.",
+    ),
+    DecisionImpactDefinition(
+        impact_id="impact_007_deferred",
+        action="deferred",
+        title="Deferred decision impact",
+        tone="neutral",
+        summary_template="Choosing deferred changes how this reason can support future recall.",
+        recall_effect="Future answers will treat this source according to the deferred decision.",
+        graph_effect="The graph keeps traceability while the trust status changes to deferred.",
+        open_loop_effect="Open loops are preserved unless the user separately resolves them.",
+        user_pressure="Keep this preview to one sentence by default.",
+        warnings=("Deferred items remain visible in future review sessions.",),
+        confirmation_question="Is deferred the decision the user would stand behind later?",
+        next_step="Apply deferred only after the evidence summary is readable.",
+    ),
+    DecisionImpactDefinition(
+        impact_id="impact_008_confirmed",
+        action="confirmed",
+        title="Confirmed decision impact",
+        tone="positive",
+        summary_template="Choosing confirmed changes how this reason can support future recall.",
+        recall_effect="Future answers will treat this source according to the confirmed decision.",
+        graph_effect="The graph keeps traceability while the trust status changes to confirmed.",
+        open_loop_effect="Open loops are preserved unless the user separately resolves them.",
+        user_pressure="Keep this preview to one sentence by default.",
+        warnings=("Only confirm when the saved reason matches user intent.",),
+        confirmation_question="Is confirmed the decision the user would stand behind later?",
+        next_step="Apply confirmed only after the evidence summary is readable.",
+    ),
+    DecisionImpactDefinition(
+        impact_id="impact_009_rewritten",
+        action="rewritten",
+        title="Rewritten decision impact",
+        tone="constructive",
+        summary_template="Choosing rewritten changes how this reason can support future recall.",
+        recall_effect="Future answers will treat this source according to the rewritten decision.",
+        graph_effect="The graph keeps traceability while the trust status changes to rewritten.",
+        open_loop_effect="Open loops are preserved unless the user separately resolves them.",
+        user_pressure="Keep this preview to one sentence by default.",
+        warnings=("Rewrite should replace the reason without deleting traceability.",),
+        confirmation_question="Is rewritten the decision the user would stand behind later?",
+        next_step="Apply rewritten only after the evidence summary is readable.",
+    ),
+    DecisionImpactDefinition(
+        impact_id="impact_010_rejected",
+        action="rejected",
+        title="Rejected decision impact",
+        tone="danger",
+        summary_template="Choosing rejected changes how this reason can support future recall.",
+        recall_effect="Future answers will treat this source according to the rejected decision.",
+        graph_effect="The graph keeps traceability while the trust status changes to rejected.",
+        open_loop_effect="Open loops are preserved unless the user separately resolves them.",
+        user_pressure="Keep this preview to one sentence by default.",
+        warnings=("Rejected context should not be reused as a trusted reason.",),
+        confirmation_question="Is rejected the decision the user would stand behind later?",
+        next_step="Apply rejected only after the evidence summary is readable.",
+    ),
+    DecisionImpactDefinition(
+        impact_id="impact_011_deferred",
+        action="deferred",
+        title="Deferred decision impact",
+        tone="neutral",
+        summary_template="Choosing deferred changes how this reason can support future recall.",
+        recall_effect="Future answers will treat this source according to the deferred decision.",
+        graph_effect="The graph keeps traceability while the trust status changes to deferred.",
+        open_loop_effect="Open loops are preserved unless the user separately resolves them.",
+        user_pressure="Keep this preview to one sentence by default.",
+        warnings=("Deferred items remain visible in future review sessions.",),
+        confirmation_question="Is deferred the decision the user would stand behind later?",
+        next_step="Apply deferred only after the evidence summary is readable.",
+    ),
+    DecisionImpactDefinition(
+        impact_id="impact_012_confirmed",
+        action="confirmed",
+        title="Confirmed decision impact",
+        tone="positive",
+        summary_template="Choosing confirmed changes how this reason can support future recall.",
+        recall_effect="Future answers will treat this source according to the confirmed decision.",
+        graph_effect="The graph keeps traceability while the trust status changes to confirmed.",
+        open_loop_effect="Open loops are preserved unless the user separately resolves them.",
+        user_pressure="Keep this preview to one sentence by default.",
+        warnings=("Only confirm when the saved reason matches user intent.",),
+        confirmation_question="Is confirmed the decision the user would stand behind later?",
+        next_step="Apply confirmed only after the evidence summary is readable.",
+    ),
+    DecisionImpactDefinition(
+        impact_id="impact_013_rewritten",
+        action="rewritten",
+        title="Rewritten decision impact",
+        tone="constructive",
+        summary_template="Choosing rewritten changes how this reason can support future recall.",
+        recall_effect="Future answers will treat this source according to the rewritten decision.",
+        graph_effect="The graph keeps traceability while the trust status changes to rewritten.",
+        open_loop_effect="Open loops are preserved unless the user separately resolves them.",
+        user_pressure="Keep this preview to one sentence by default.",
+        warnings=("Rewrite should replace the reason without deleting traceability.",),
+        confirmation_question="Is rewritten the decision the user would stand behind later?",
+        next_step="Apply rewritten only after the evidence summary is readable.",
+    ),
+    DecisionImpactDefinition(
+        impact_id="impact_014_rejected",
+        action="rejected",
+        title="Rejected decision impact",
+        tone="danger",
+        summary_template="Choosing rejected changes how this reason can support future recall.",
+        recall_effect="Future answers will treat this source according to the rejected decision.",
+        graph_effect="The graph keeps traceability while the trust status changes to rejected.",
+        open_loop_effect="Open loops are preserved unless the user separately resolves them.",
+        user_pressure="Keep this preview to one sentence by default.",
+        warnings=("Rejected context should not be reused as a trusted reason.",),
+        confirmation_question="Is rejected the decision the user would stand behind later?",
+        next_step="Apply rejected only after the evidence summary is readable.",
+    ),
+    DecisionImpactDefinition(
+        impact_id="impact_015_deferred",
+        action="deferred",
+        title="Deferred decision impact",
+        tone="neutral",
+        summary_template="Choosing deferred changes how this reason can support future recall.",
+        recall_effect="Future answers will treat this source according to the deferred decision.",
+        graph_effect="The graph keeps traceability while the trust status changes to deferred.",
+        open_loop_effect="Open loops are preserved unless the user separately resolves them.",
+        user_pressure="Keep this preview to one sentence by default.",
+        warnings=("Deferred items remain visible in future review sessions.",),
+        confirmation_question="Is deferred the decision the user would stand behind later?",
+        next_step="Apply deferred only after the evidence summary is readable.",
+    ),
+    DecisionImpactDefinition(
+        impact_id="impact_016_confirmed",
+        action="confirmed",
+        title="Confirmed decision impact",
+        tone="positive",
+        summary_template="Choosing confirmed changes how this reason can support future recall.",
+        recall_effect="Future answers will treat this source according to the confirmed decision.",
+        graph_effect="The graph keeps traceability while the trust status changes to confirmed.",
+        open_loop_effect="Open loops are preserved unless the user separately resolves them.",
+        user_pressure="Keep this preview to one sentence by default.",
+        warnings=("Only confirm when the saved reason matches user intent.",),
+        confirmation_question="Is confirmed the decision the user would stand behind later?",
+        next_step="Apply confirmed only after the evidence summary is readable.",
+    ),
+    DecisionImpactDefinition(
+        impact_id="impact_017_rewritten",
+        action="rewritten",
+        title="Rewritten decision impact",
+        tone="constructive",
+        summary_template="Choosing rewritten changes how this reason can support future recall.",
+        recall_effect="Future answers will treat this source according to the rewritten decision.",
+        graph_effect="The graph keeps traceability while the trust status changes to rewritten.",
+        open_loop_effect="Open loops are preserved unless the user separately resolves them.",
+        user_pressure="Keep this preview to one sentence by default.",
+        warnings=("Rewrite should replace the reason without deleting traceability.",),
+        confirmation_question="Is rewritten the decision the user would stand behind later?",
+        next_step="Apply rewritten only after the evidence summary is readable.",
+    ),
+    DecisionImpactDefinition(
+        impact_id="impact_018_rejected",
+        action="rejected",
+        title="Rejected decision impact",
+        tone="danger",
+        summary_template="Choosing rejected changes how this reason can support future recall.",
+        recall_effect="Future answers will treat this source according to the rejected decision.",
+        graph_effect="The graph keeps traceability while the trust status changes to rejected.",
+        open_loop_effect="Open loops are preserved unless the user separately resolves them.",
+        user_pressure="Keep this preview to one sentence by default.",
+        warnings=("Rejected context should not be reused as a trusted reason.",),
+        confirmation_question="Is rejected the decision the user would stand behind later?",
+        next_step="Apply rejected only after the evidence summary is readable.",
+    ),
+    DecisionImpactDefinition(
+        impact_id="impact_019_deferred",
+        action="deferred",
+        title="Deferred decision impact",
+        tone="neutral",
+        summary_template="Choosing deferred changes how this reason can support future recall.",
+        recall_effect="Future answers will treat this source according to the deferred decision.",
+        graph_effect="The graph keeps traceability while the trust status changes to deferred.",
+        open_loop_effect="Open loops are preserved unless the user separately resolves them.",
+        user_pressure="Keep this preview to one sentence by default.",
+        warnings=("Deferred items remain visible in future review sessions.",),
+        confirmation_question="Is deferred the decision the user would stand behind later?",
+        next_step="Apply deferred only after the evidence summary is readable.",
+    ),
+    DecisionImpactDefinition(
+        impact_id="impact_020_confirmed",
+        action="confirmed",
+        title="Confirmed decision impact",
+        tone="positive",
+        summary_template="Choosing confirmed changes how this reason can support future recall.",
+        recall_effect="Future answers will treat this source according to the confirmed decision.",
+        graph_effect="The graph keeps traceability while the trust status changes to confirmed.",
+        open_loop_effect="Open loops are preserved unless the user separately resolves them.",
+        user_pressure="Keep this preview to one sentence by default.",
+        warnings=("Only confirm when the saved reason matches user intent.",),
+        confirmation_question="Is confirmed the decision the user would stand behind later?",
+        next_step="Apply confirmed only after the evidence summary is readable.",
+    ),
+    DecisionImpactDefinition(
+        impact_id="impact_021_rewritten",
+        action="rewritten",
+        title="Rewritten decision impact",
+        tone="constructive",
+        summary_template="Choosing rewritten changes how this reason can support future recall.",
+        recall_effect="Future answers will treat this source according to the rewritten decision.",
+        graph_effect="The graph keeps traceability while the trust status changes to rewritten.",
+        open_loop_effect="Open loops are preserved unless the user separately resolves them.",
+        user_pressure="Keep this preview to one sentence by default.",
+        warnings=("Rewrite should replace the reason without deleting traceability.",),
+        confirmation_question="Is rewritten the decision the user would stand behind later?",
+        next_step="Apply rewritten only after the evidence summary is readable.",
+    ),
+    DecisionImpactDefinition(
+        impact_id="impact_022_rejected",
+        action="rejected",
+        title="Rejected decision impact",
+        tone="danger",
+        summary_template="Choosing rejected changes how this reason can support future recall.",
+        recall_effect="Future answers will treat this source according to the rejected decision.",
+        graph_effect="The graph keeps traceability while the trust status changes to rejected.",
+        open_loop_effect="Open loops are preserved unless the user separately resolves them.",
+        user_pressure="Keep this preview to one sentence by default.",
+        warnings=("Rejected context should not be reused as a trusted reason.",),
+        confirmation_question="Is rejected the decision the user would stand behind later?",
+        next_step="Apply rejected only after the evidence summary is readable.",
+    ),
+    DecisionImpactDefinition(
+        impact_id="impact_023_deferred",
+        action="deferred",
+        title="Deferred decision impact",
+        tone="neutral",
+        summary_template="Choosing deferred changes how this reason can support future recall.",
+        recall_effect="Future answers will treat this source according to the deferred decision.",
+        graph_effect="The graph keeps traceability while the trust status changes to deferred.",
+        open_loop_effect="Open loops are preserved unless the user separately resolves them.",
+        user_pressure="Keep this preview to one sentence by default.",
+        warnings=("Deferred items remain visible in future review sessions.",),
+        confirmation_question="Is deferred the decision the user would stand behind later?",
+        next_step="Apply deferred only after the evidence summary is readable.",
+    ),
+    DecisionImpactDefinition(
+        impact_id="impact_024_confirmed",
+        action="confirmed",
+        title="Confirmed decision impact",
+        tone="positive",
+        summary_template="Choosing confirmed changes how this reason can support future recall.",
+        recall_effect="Future answers will treat this source according to the confirmed decision.",
+        graph_effect="The graph keeps traceability while the trust status changes to confirmed.",
+        open_loop_effect="Open loops are preserved unless the user separately resolves them.",
+        user_pressure="Keep this preview to one sentence by default.",
+        warnings=("Only confirm when the saved reason matches user intent.",),
+        confirmation_question="Is confirmed the decision the user would stand behind later?",
+        next_step="Apply confirmed only after the evidence summary is readable.",
+    ),
+    DecisionImpactDefinition(
+        impact_id="impact_025_rewritten",
+        action="rewritten",
+        title="Rewritten decision impact",
+        tone="constructive",
+        summary_template="Choosing rewritten changes how this reason can support future recall.",
+        recall_effect="Future answers will treat this source according to the rewritten decision.",
+        graph_effect="The graph keeps traceability while the trust status changes to rewritten.",
+        open_loop_effect="Open loops are preserved unless the user separately resolves them.",
+        user_pressure="Keep this preview to one sentence by default.",
+        warnings=("Rewrite should replace the reason without deleting traceability.",),
+        confirmation_question="Is rewritten the decision the user would stand behind later?",
+        next_step="Apply rewritten only after the evidence summary is readable.",
+    ),
+    DecisionImpactDefinition(
+        impact_id="impact_026_rejected",
+        action="rejected",
+        title="Rejected decision impact",
+        tone="danger",
+        summary_template="Choosing rejected changes how this reason can support future recall.",
+        recall_effect="Future answers will treat this source according to the rejected decision.",
+        graph_effect="The graph keeps traceability while the trust status changes to rejected.",
+        open_loop_effect="Open loops are preserved unless the user separately resolves them.",
+        user_pressure="Keep this preview to one sentence by default.",
+        warnings=("Rejected context should not be reused as a trusted reason.",),
+        confirmation_question="Is rejected the decision the user would stand behind later?",
+        next_step="Apply rejected only after the evidence summary is readable.",
+    ),
+    DecisionImpactDefinition(
+        impact_id="impact_027_deferred",
+        action="deferred",
+        title="Deferred decision impact",
+        tone="neutral",
+        summary_template="Choosing deferred changes how this reason can support future recall.",
+        recall_effect="Future answers will treat this source according to the deferred decision.",
+        graph_effect="The graph keeps traceability while the trust status changes to deferred.",
+        open_loop_effect="Open loops are preserved unless the user separately resolves them.",
+        user_pressure="Keep this preview to one sentence by default.",
+        warnings=("Deferred items remain visible in future review sessions.",),
+        confirmation_question="Is deferred the decision the user would stand behind later?",
+        next_step="Apply deferred only after the evidence summary is readable.",
+    ),
+    DecisionImpactDefinition(
+        impact_id="impact_028_confirmed",
+        action="confirmed",
+        title="Confirmed decision impact",
+        tone="positive",
+        summary_template="Choosing confirmed changes how this reason can support future recall.",
+        recall_effect="Future answers will treat this source according to the confirmed decision.",
+        graph_effect="The graph keeps traceability while the trust status changes to confirmed.",
+        open_loop_effect="Open loops are preserved unless the user separately resolves them.",
+        user_pressure="Keep this preview to one sentence by default.",
+        warnings=("Only confirm when the saved reason matches user intent.",),
+        confirmation_question="Is confirmed the decision the user would stand behind later?",
+        next_step="Apply confirmed only after the evidence summary is readable.",
+    ),
+    DecisionImpactDefinition(
+        impact_id="impact_029_rewritten",
+        action="rewritten",
+        title="Rewritten decision impact",
+        tone="constructive",
+        summary_template="Choosing rewritten changes how this reason can support future recall.",
+        recall_effect="Future answers will treat this source according to the rewritten decision.",
+        graph_effect="The graph keeps traceability while the trust status changes to rewritten.",
+        open_loop_effect="Open loops are preserved unless the user separately resolves them.",
+        user_pressure="Keep this preview to one sentence by default.",
+        warnings=("Rewrite should replace the reason without deleting traceability.",),
+        confirmation_question="Is rewritten the decision the user would stand behind later?",
+        next_step="Apply rewritten only after the evidence summary is readable.",
+    ),
+    DecisionImpactDefinition(
+        impact_id="impact_030_rejected",
+        action="rejected",
+        title="Rejected decision impact",
+        tone="danger",
+        summary_template="Choosing rejected changes how this reason can support future recall.",
+        recall_effect="Future answers will treat this source according to the rejected decision.",
+        graph_effect="The graph keeps traceability while the trust status changes to rejected.",
+        open_loop_effect="Open loops are preserved unless the user separately resolves them.",
+        user_pressure="Keep this preview to one sentence by default.",
+        warnings=("Rejected context should not be reused as a trusted reason.",),
+        confirmation_question="Is rejected the decision the user would stand behind later?",
+        next_step="Apply rejected only after the evidence summary is readable.",
+    ),
+    DecisionImpactDefinition(
+        impact_id="impact_031_deferred",
+        action="deferred",
+        title="Deferred decision impact",
+        tone="neutral",
+        summary_template="Choosing deferred changes how this reason can support future recall.",
+        recall_effect="Future answers will treat this source according to the deferred decision.",
+        graph_effect="The graph keeps traceability while the trust status changes to deferred.",
+        open_loop_effect="Open loops are preserved unless the user separately resolves them.",
+        user_pressure="Keep this preview to one sentence by default.",
+        warnings=("Deferred items remain visible in future review sessions.",),
+        confirmation_question="Is deferred the decision the user would stand behind later?",
+        next_step="Apply deferred only after the evidence summary is readable.",
+    ),
+    DecisionImpactDefinition(
+        impact_id="impact_032_confirmed",
+        action="confirmed",
+        title="Confirmed decision impact",
+        tone="positive",
+        summary_template="Choosing confirmed changes how this reason can support future recall.",
+        recall_effect="Future answers will treat this source according to the confirmed decision.",
+        graph_effect="The graph keeps traceability while the trust status changes to confirmed.",
+        open_loop_effect="Open loops are preserved unless the user separately resolves them.",
+        user_pressure="Keep this preview to one sentence by default.",
+        warnings=("Only confirm when the saved reason matches user intent.",),
+        confirmation_question="Is confirmed the decision the user would stand behind later?",
+        next_step="Apply confirmed only after the evidence summary is readable.",
+    ),
+    DecisionImpactDefinition(
+        impact_id="impact_033_rewritten",
+        action="rewritten",
+        title="Rewritten decision impact",
+        tone="constructive",
+        summary_template="Choosing rewritten changes how this reason can support future recall.",
+        recall_effect="Future answers will treat this source according to the rewritten decision.",
+        graph_effect="The graph keeps traceability while the trust status changes to rewritten.",
+        open_loop_effect="Open loops are preserved unless the user separately resolves them.",
+        user_pressure="Keep this preview to one sentence by default.",
+        warnings=("Rewrite should replace the reason without deleting traceability.",),
+        confirmation_question="Is rewritten the decision the user would stand behind later?",
+        next_step="Apply rewritten only after the evidence summary is readable.",
+    ),
+    DecisionImpactDefinition(
+        impact_id="impact_034_rejected",
+        action="rejected",
+        title="Rejected decision impact",
+        tone="danger",
+        summary_template="Choosing rejected changes how this reason can support future recall.",
+        recall_effect="Future answers will treat this source according to the rejected decision.",
+        graph_effect="The graph keeps traceability while the trust status changes to rejected.",
+        open_loop_effect="Open loops are preserved unless the user separately resolves them.",
+        user_pressure="Keep this preview to one sentence by default.",
+        warnings=("Rejected context should not be reused as a trusted reason.",),
+        confirmation_question="Is rejected the decision the user would stand behind later?",
+        next_step="Apply rejected only after the evidence summary is readable.",
+    ),
+    DecisionImpactDefinition(
+        impact_id="impact_035_deferred",
+        action="deferred",
+        title="Deferred decision impact",
+        tone="neutral",
+        summary_template="Choosing deferred changes how this reason can support future recall.",
+        recall_effect="Future answers will treat this source according to the deferred decision.",
+        graph_effect="The graph keeps traceability while the trust status changes to deferred.",
+        open_loop_effect="Open loops are preserved unless the user separately resolves them.",
+        user_pressure="Keep this preview to one sentence by default.",
+        warnings=("Deferred items remain visible in future review sessions.",),
+        confirmation_question="Is deferred the decision the user would stand behind later?",
+        next_step="Apply deferred only after the evidence summary is readable.",
+    ),
+    DecisionImpactDefinition(
+        impact_id="impact_036_confirmed",
+        action="confirmed",
+        title="Confirmed decision impact",
+        tone="positive",
+        summary_template="Choosing confirmed changes how this reason can support future recall.",
+        recall_effect="Future answers will treat this source according to the confirmed decision.",
+        graph_effect="The graph keeps traceability while the trust status changes to confirmed.",
+        open_loop_effect="Open loops are preserved unless the user separately resolves them.",
+        user_pressure="Keep this preview to one sentence by default.",
+        warnings=("Only confirm when the saved reason matches user intent.",),
+        confirmation_question="Is confirmed the decision the user would stand behind later?",
+        next_step="Apply confirmed only after the evidence summary is readable.",
+    ),
+    DecisionImpactDefinition(
+        impact_id="impact_037_rewritten",
+        action="rewritten",
+        title="Rewritten decision impact",
+        tone="constructive",
+        summary_template="Choosing rewritten changes how this reason can support future recall.",
+        recall_effect="Future answers will treat this source according to the rewritten decision.",
+        graph_effect="The graph keeps traceability while the trust status changes to rewritten.",
+        open_loop_effect="Open loops are preserved unless the user separately resolves them.",
+        user_pressure="Keep this preview to one sentence by default.",
+        warnings=("Rewrite should replace the reason without deleting traceability.",),
+        confirmation_question="Is rewritten the decision the user would stand behind later?",
+        next_step="Apply rewritten only after the evidence summary is readable.",
+    ),
+    DecisionImpactDefinition(
+        impact_id="impact_038_rejected",
+        action="rejected",
+        title="Rejected decision impact",
+        tone="danger",
+        summary_template="Choosing rejected changes how this reason can support future recall.",
+        recall_effect="Future answers will treat this source according to the rejected decision.",
+        graph_effect="The graph keeps traceability while the trust status changes to rejected.",
+        open_loop_effect="Open loops are preserved unless the user separately resolves them.",
+        user_pressure="Keep this preview to one sentence by default.",
+        warnings=("Rejected context should not be reused as a trusted reason.",),
+        confirmation_question="Is rejected the decision the user would stand behind later?",
+        next_step="Apply rejected only after the evidence summary is readable.",
+    ),
+    DecisionImpactDefinition(
+        impact_id="impact_039_deferred",
+        action="deferred",
+        title="Deferred decision impact",
+        tone="neutral",
+        summary_template="Choosing deferred changes how this reason can support future recall.",
+        recall_effect="Future answers will treat this source according to the deferred decision.",
+        graph_effect="The graph keeps traceability while the trust status changes to deferred.",
+        open_loop_effect="Open loops are preserved unless the user separately resolves them.",
+        user_pressure="Keep this preview to one sentence by default.",
+        warnings=("Deferred items remain visible in future review sessions.",),
+        confirmation_question="Is deferred the decision the user would stand behind later?",
+        next_step="Apply deferred only after the evidence summary is readable.",
+    ),
+    DecisionImpactDefinition(
+        impact_id="impact_040_confirmed",
+        action="confirmed",
+        title="Confirmed decision impact",
+        tone="positive",
+        summary_template="Choosing confirmed changes how this reason can support future recall.",
+        recall_effect="Future answers will treat this source according to the confirmed decision.",
+        graph_effect="The graph keeps traceability while the trust status changes to confirmed.",
+        open_loop_effect="Open loops are preserved unless the user separately resolves them.",
+        user_pressure="Keep this preview to one sentence by default.",
+        warnings=("Only confirm when the saved reason matches user intent.",),
+        confirmation_question="Is confirmed the decision the user would stand behind later?",
+        next_step="Apply confirmed only after the evidence summary is readable.",
+    ),
+    DecisionImpactDefinition(
+        impact_id="impact_041_rewritten",
+        action="rewritten",
+        title="Rewritten decision impact",
+        tone="constructive",
+        summary_template="Choosing rewritten changes how this reason can support future recall.",
+        recall_effect="Future answers will treat this source according to the rewritten decision.",
+        graph_effect="The graph keeps traceability while the trust status changes to rewritten.",
+        open_loop_effect="Open loops are preserved unless the user separately resolves them.",
+        user_pressure="Keep this preview to one sentence by default.",
+        warnings=("Rewrite should replace the reason without deleting traceability.",),
+        confirmation_question="Is rewritten the decision the user would stand behind later?",
+        next_step="Apply rewritten only after the evidence summary is readable.",
+    ),
+    DecisionImpactDefinition(
+        impact_id="impact_042_rejected",
+        action="rejected",
+        title="Rejected decision impact",
+        tone="danger",
+        summary_template="Choosing rejected changes how this reason can support future recall.",
+        recall_effect="Future answers will treat this source according to the rejected decision.",
+        graph_effect="The graph keeps traceability while the trust status changes to rejected.",
+        open_loop_effect="Open loops are preserved unless the user separately resolves them.",
+        user_pressure="Keep this preview to one sentence by default.",
+        warnings=("Rejected context should not be reused as a trusted reason.",),
+        confirmation_question="Is rejected the decision the user would stand behind later?",
+        next_step="Apply rejected only after the evidence summary is readable.",
+    ),
+    DecisionImpactDefinition(
+        impact_id="impact_043_deferred",
+        action="deferred",
+        title="Deferred decision impact",
+        tone="neutral",
+        summary_template="Choosing deferred changes how this reason can support future recall.",
+        recall_effect="Future answers will treat this source according to the deferred decision.",
+        graph_effect="The graph keeps traceability while the trust status changes to deferred.",
+        open_loop_effect="Open loops are preserved unless the user separately resolves them.",
+        user_pressure="Keep this preview to one sentence by default.",
+        warnings=("Deferred items remain visible in future review sessions.",),
+        confirmation_question="Is deferred the decision the user would stand behind later?",
+        next_step="Apply deferred only after the evidence summary is readable.",
+    ),
+    DecisionImpactDefinition(
+        impact_id="impact_044_confirmed",
+        action="confirmed",
+        title="Confirmed decision impact",
+        tone="positive",
+        summary_template="Choosing confirmed changes how this reason can support future recall.",
+        recall_effect="Future answers will treat this source according to the confirmed decision.",
+        graph_effect="The graph keeps traceability while the trust status changes to confirmed.",
+        open_loop_effect="Open loops are preserved unless the user separately resolves them.",
+        user_pressure="Keep this preview to one sentence by default.",
+        warnings=("Only confirm when the saved reason matches user intent.",),
+        confirmation_question="Is confirmed the decision the user would stand behind later?",
+        next_step="Apply confirmed only after the evidence summary is readable.",
+    ),
+    DecisionImpactDefinition(
+        impact_id="impact_045_rewritten",
+        action="rewritten",
+        title="Rewritten decision impact",
+        tone="constructive",
+        summary_template="Choosing rewritten changes how this reason can support future recall.",
+        recall_effect="Future answers will treat this source according to the rewritten decision.",
+        graph_effect="The graph keeps traceability while the trust status changes to rewritten.",
+        open_loop_effect="Open loops are preserved unless the user separately resolves them.",
+        user_pressure="Keep this preview to one sentence by default.",
+        warnings=("Rewrite should replace the reason without deleting traceability.",),
+        confirmation_question="Is rewritten the decision the user would stand behind later?",
+        next_step="Apply rewritten only after the evidence summary is readable.",
+    ),
+    DecisionImpactDefinition(
+        impact_id="impact_046_rejected",
+        action="rejected",
+        title="Rejected decision impact",
+        tone="danger",
+        summary_template="Choosing rejected changes how this reason can support future recall.",
+        recall_effect="Future answers will treat this source according to the rejected decision.",
+        graph_effect="The graph keeps traceability while the trust status changes to rejected.",
+        open_loop_effect="Open loops are preserved unless the user separately resolves them.",
+        user_pressure="Keep this preview to one sentence by default.",
+        warnings=("Rejected context should not be reused as a trusted reason.",),
+        confirmation_question="Is rejected the decision the user would stand behind later?",
+        next_step="Apply rejected only after the evidence summary is readable.",
+    ),
+    DecisionImpactDefinition(
+        impact_id="impact_047_deferred",
+        action="deferred",
+        title="Deferred decision impact",
+        tone="neutral",
+        summary_template="Choosing deferred changes how this reason can support future recall.",
+        recall_effect="Future answers will treat this source according to the deferred decision.",
+        graph_effect="The graph keeps traceability while the trust status changes to deferred.",
+        open_loop_effect="Open loops are preserved unless the user separately resolves them.",
+        user_pressure="Keep this preview to one sentence by default.",
+        warnings=("Deferred items remain visible in future review sessions.",),
+        confirmation_question="Is deferred the decision the user would stand behind later?",
+        next_step="Apply deferred only after the evidence summary is readable.",
+    ),
+    DecisionImpactDefinition(
+        impact_id="impact_048_confirmed",
+        action="confirmed",
+        title="Confirmed decision impact",
+        tone="positive",
+        summary_template="Choosing confirmed changes how this reason can support future recall.",
+        recall_effect="Future answers will treat this source according to the confirmed decision.",
+        graph_effect="The graph keeps traceability while the trust status changes to confirmed.",
+        open_loop_effect="Open loops are preserved unless the user separately resolves them.",
+        user_pressure="Keep this preview to one sentence by default.",
+        warnings=("Only confirm when the saved reason matches user intent.",),
+        confirmation_question="Is confirmed the decision the user would stand behind later?",
+        next_step="Apply confirmed only after the evidence summary is readable.",
+    ),
+    DecisionImpactDefinition(
+        impact_id="impact_049_rewritten",
+        action="rewritten",
+        title="Rewritten decision impact",
+        tone="constructive",
+        summary_template="Choosing rewritten changes how this reason can support future recall.",
+        recall_effect="Future answers will treat this source according to the rewritten decision.",
+        graph_effect="The graph keeps traceability while the trust status changes to rewritten.",
+        open_loop_effect="Open loops are preserved unless the user separately resolves them.",
+        user_pressure="Keep this preview to one sentence by default.",
+        warnings=("Rewrite should replace the reason without deleting traceability.",),
+        confirmation_question="Is rewritten the decision the user would stand behind later?",
+        next_step="Apply rewritten only after the evidence summary is readable.",
+    ),
+    DecisionImpactDefinition(
+        impact_id="impact_050_rejected",
+        action="rejected",
+        title="Rejected decision impact",
+        tone="danger",
+        summary_template="Choosing rejected changes how this reason can support future recall.",
+        recall_effect="Future answers will treat this source according to the rejected decision.",
+        graph_effect="The graph keeps traceability while the trust status changes to rejected.",
+        open_loop_effect="Open loops are preserved unless the user separately resolves them.",
+        user_pressure="Keep this preview to one sentence by default.",
+        warnings=("Rejected context should not be reused as a trusted reason.",),
+        confirmation_question="Is rejected the decision the user would stand behind later?",
+        next_step="Apply rejected only after the evidence summary is readable.",
+    ),
+    DecisionImpactDefinition(
+        impact_id="impact_051_deferred",
+        action="deferred",
+        title="Deferred decision impact",
+        tone="neutral",
+        summary_template="Choosing deferred changes how this reason can support future recall.",
+        recall_effect="Future answers will treat this source according to the deferred decision.",
+        graph_effect="The graph keeps traceability while the trust status changes to deferred.",
+        open_loop_effect="Open loops are preserved unless the user separately resolves them.",
+        user_pressure="Keep this preview to one sentence by default.",
+        warnings=("Deferred items remain visible in future review sessions.",),
+        confirmation_question="Is deferred the decision the user would stand behind later?",
+        next_step="Apply deferred only after the evidence summary is readable.",
+    ),
+    DecisionImpactDefinition(
+        impact_id="impact_052_confirmed",
+        action="confirmed",
+        title="Confirmed decision impact",
+        tone="positive",
+        summary_template="Choosing confirmed changes how this reason can support future recall.",
+        recall_effect="Future answers will treat this source according to the confirmed decision.",
+        graph_effect="The graph keeps traceability while the trust status changes to confirmed.",
+        open_loop_effect="Open loops are preserved unless the user separately resolves them.",
+        user_pressure="Keep this preview to one sentence by default.",
+        warnings=("Only confirm when the saved reason matches user intent.",),
+        confirmation_question="Is confirmed the decision the user would stand behind later?",
+        next_step="Apply confirmed only after the evidence summary is readable.",
+    ),
+    DecisionImpactDefinition(
+        impact_id="impact_053_rewritten",
+        action="rewritten",
+        title="Rewritten decision impact",
+        tone="constructive",
+        summary_template="Choosing rewritten changes how this reason can support future recall.",
+        recall_effect="Future answers will treat this source according to the rewritten decision.",
+        graph_effect="The graph keeps traceability while the trust status changes to rewritten.",
+        open_loop_effect="Open loops are preserved unless the user separately resolves them.",
+        user_pressure="Keep this preview to one sentence by default.",
+        warnings=("Rewrite should replace the reason without deleting traceability.",),
+        confirmation_question="Is rewritten the decision the user would stand behind later?",
+        next_step="Apply rewritten only after the evidence summary is readable.",
+    ),
+    DecisionImpactDefinition(
+        impact_id="impact_054_rejected",
+        action="rejected",
+        title="Rejected decision impact",
+        tone="danger",
+        summary_template="Choosing rejected changes how this reason can support future recall.",
+        recall_effect="Future answers will treat this source according to the rejected decision.",
+        graph_effect="The graph keeps traceability while the trust status changes to rejected.",
+        open_loop_effect="Open loops are preserved unless the user separately resolves them.",
+        user_pressure="Keep this preview to one sentence by default.",
+        warnings=("Rejected context should not be reused as a trusted reason.",),
+        confirmation_question="Is rejected the decision the user would stand behind later?",
+        next_step="Apply rejected only after the evidence summary is readable.",
+    ),
+    DecisionImpactDefinition(
+        impact_id="impact_055_deferred",
+        action="deferred",
+        title="Deferred decision impact",
+        tone="neutral",
+        summary_template="Choosing deferred changes how this reason can support future recall.",
+        recall_effect="Future answers will treat this source according to the deferred decision.",
+        graph_effect="The graph keeps traceability while the trust status changes to deferred.",
+        open_loop_effect="Open loops are preserved unless the user separately resolves them.",
+        user_pressure="Keep this preview to one sentence by default.",
+        warnings=("Deferred items remain visible in future review sessions.",),
+        confirmation_question="Is deferred the decision the user would stand behind later?",
+        next_step="Apply deferred only after the evidence summary is readable.",
+    ),
+    DecisionImpactDefinition(
+        impact_id="impact_056_confirmed",
+        action="confirmed",
+        title="Confirmed decision impact",
+        tone="positive",
+        summary_template="Choosing confirmed changes how this reason can support future recall.",
+        recall_effect="Future answers will treat this source according to the confirmed decision.",
+        graph_effect="The graph keeps traceability while the trust status changes to confirmed.",
+        open_loop_effect="Open loops are preserved unless the user separately resolves them.",
+        user_pressure="Keep this preview to one sentence by default.",
+        warnings=("Only confirm when the saved reason matches user intent.",),
+        confirmation_question="Is confirmed the decision the user would stand behind later?",
+        next_step="Apply confirmed only after the evidence summary is readable.",
+    ),
+    DecisionImpactDefinition(
+        impact_id="impact_057_rewritten",
+        action="rewritten",
+        title="Rewritten decision impact",
+        tone="constructive",
+        summary_template="Choosing rewritten changes how this reason can support future recall.",
+        recall_effect="Future answers will treat this source according to the rewritten decision.",
+        graph_effect="The graph keeps traceability while the trust status changes to rewritten.",
+        open_loop_effect="Open loops are preserved unless the user separately resolves them.",
+        user_pressure="Keep this preview to one sentence by default.",
+        warnings=("Rewrite should replace the reason without deleting traceability.",),
+        confirmation_question="Is rewritten the decision the user would stand behind later?",
+        next_step="Apply rewritten only after the evidence summary is readable.",
+    ),
+    DecisionImpactDefinition(
+        impact_id="impact_058_rejected",
+        action="rejected",
+        title="Rejected decision impact",
+        tone="danger",
+        summary_template="Choosing rejected changes how this reason can support future recall.",
+        recall_effect="Future answers will treat this source according to the rejected decision.",
+        graph_effect="The graph keeps traceability while the trust status changes to rejected.",
+        open_loop_effect="Open loops are preserved unless the user separately resolves them.",
+        user_pressure="Keep this preview to one sentence by default.",
+        warnings=("Rejected context should not be reused as a trusted reason.",),
+        confirmation_question="Is rejected the decision the user would stand behind later?",
+        next_step="Apply rejected only after the evidence summary is readable.",
+    ),
+    DecisionImpactDefinition(
+        impact_id="impact_059_deferred",
+        action="deferred",
+        title="Deferred decision impact",
+        tone="neutral",
+        summary_template="Choosing deferred changes how this reason can support future recall.",
+        recall_effect="Future answers will treat this source according to the deferred decision.",
+        graph_effect="The graph keeps traceability while the trust status changes to deferred.",
+        open_loop_effect="Open loops are preserved unless the user separately resolves them.",
+        user_pressure="Keep this preview to one sentence by default.",
+        warnings=("Deferred items remain visible in future review sessions.",),
+        confirmation_question="Is deferred the decision the user would stand behind later?",
+        next_step="Apply deferred only after the evidence summary is readable.",
+    ),
+    DecisionImpactDefinition(
+        impact_id="impact_060_confirmed",
+        action="confirmed",
+        title="Confirmed decision impact",
+        tone="positive",
+        summary_template="Choosing confirmed changes how this reason can support future recall.",
+        recall_effect="Future answers will treat this source according to the confirmed decision.",
+        graph_effect="The graph keeps traceability while the trust status changes to confirmed.",
+        open_loop_effect="Open loops are preserved unless the user separately resolves them.",
+        user_pressure="Keep this preview to one sentence by default.",
+        warnings=("Only confirm when the saved reason matches user intent.",),
+        confirmation_question="Is confirmed the decision the user would stand behind later?",
+        next_step="Apply confirmed only after the evidence summary is readable.",
+    ),
+    DecisionImpactDefinition(
+        impact_id="impact_061_rewritten",
+        action="rewritten",
+        title="Rewritten decision impact",
+        tone="constructive",
+        summary_template="Choosing rewritten changes how this reason can support future recall.",
+        recall_effect="Future answers will treat this source according to the rewritten decision.",
+        graph_effect="The graph keeps traceability while the trust status changes to rewritten.",
+        open_loop_effect="Open loops are preserved unless the user separately resolves them.",
+        user_pressure="Keep this preview to one sentence by default.",
+        warnings=("Rewrite should replace the reason without deleting traceability.",),
+        confirmation_question="Is rewritten the decision the user would stand behind later?",
+        next_step="Apply rewritten only after the evidence summary is readable.",
+    ),
+    DecisionImpactDefinition(
+        impact_id="impact_062_rejected",
+        action="rejected",
+        title="Rejected decision impact",
+        tone="danger",
+        summary_template="Choosing rejected changes how this reason can support future recall.",
+        recall_effect="Future answers will treat this source according to the rejected decision.",
+        graph_effect="The graph keeps traceability while the trust status changes to rejected.",
+        open_loop_effect="Open loops are preserved unless the user separately resolves them.",
+        user_pressure="Keep this preview to one sentence by default.",
+        warnings=("Rejected context should not be reused as a trusted reason.",),
+        confirmation_question="Is rejected the decision the user would stand behind later?",
+        next_step="Apply rejected only after the evidence summary is readable.",
+    ),
+    DecisionImpactDefinition(
+        impact_id="impact_063_deferred",
+        action="deferred",
+        title="Deferred decision impact",
+        tone="neutral",
+        summary_template="Choosing deferred changes how this reason can support future recall.",
+        recall_effect="Future answers will treat this source according to the deferred decision.",
+        graph_effect="The graph keeps traceability while the trust status changes to deferred.",
+        open_loop_effect="Open loops are preserved unless the user separately resolves them.",
+        user_pressure="Keep this preview to one sentence by default.",
+        warnings=("Deferred items remain visible in future review sessions.",),
+        confirmation_question="Is deferred the decision the user would stand behind later?",
+        next_step="Apply deferred only after the evidence summary is readable.",
+    ),
+    DecisionImpactDefinition(
+        impact_id="impact_064_confirmed",
+        action="confirmed",
+        title="Confirmed decision impact",
+        tone="positive",
+        summary_template="Choosing confirmed changes how this reason can support future recall.",
+        recall_effect="Future answers will treat this source according to the confirmed decision.",
+        graph_effect="The graph keeps traceability while the trust status changes to confirmed.",
+        open_loop_effect="Open loops are preserved unless the user separately resolves them.",
+        user_pressure="Keep this preview to one sentence by default.",
+        warnings=("Only confirm when the saved reason matches user intent.",),
+        confirmation_question="Is confirmed the decision the user would stand behind later?",
+        next_step="Apply confirmed only after the evidence summary is readable.",
+    ),
+    DecisionImpactDefinition(
+        impact_id="impact_065_rewritten",
+        action="rewritten",
+        title="Rewritten decision impact",
+        tone="constructive",
+        summary_template="Choosing rewritten changes how this reason can support future recall.",
+        recall_effect="Future answers will treat this source according to the rewritten decision.",
+        graph_effect="The graph keeps traceability while the trust status changes to rewritten.",
+        open_loop_effect="Open loops are preserved unless the user separately resolves them.",
+        user_pressure="Keep this preview to one sentence by default.",
+        warnings=("Rewrite should replace the reason without deleting traceability.",),
+        confirmation_question="Is rewritten the decision the user would stand behind later?",
+        next_step="Apply rewritten only after the evidence summary is readable.",
+    ),
+    DecisionImpactDefinition(
+        impact_id="impact_066_rejected",
+        action="rejected",
+        title="Rejected decision impact",
+        tone="danger",
+        summary_template="Choosing rejected changes how this reason can support future recall.",
+        recall_effect="Future answers will treat this source according to the rejected decision.",
+        graph_effect="The graph keeps traceability while the trust status changes to rejected.",
+        open_loop_effect="Open loops are preserved unless the user separately resolves them.",
+        user_pressure="Keep this preview to one sentence by default.",
+        warnings=("Rejected context should not be reused as a trusted reason.",),
+        confirmation_question="Is rejected the decision the user would stand behind later?",
+        next_step="Apply rejected only after the evidence summary is readable.",
+    ),
+    DecisionImpactDefinition(
+        impact_id="impact_067_deferred",
+        action="deferred",
+        title="Deferred decision impact",
+        tone="neutral",
+        summary_template="Choosing deferred changes how this reason can support future recall.",
+        recall_effect="Future answers will treat this source according to the deferred decision.",
+        graph_effect="The graph keeps traceability while the trust status changes to deferred.",
+        open_loop_effect="Open loops are preserved unless the user separately resolves them.",
+        user_pressure="Keep this preview to one sentence by default.",
+        warnings=("Deferred items remain visible in future review sessions.",),
+        confirmation_question="Is deferred the decision the user would stand behind later?",
+        next_step="Apply deferred only after the evidence summary is readable.",
+    ),
+    DecisionImpactDefinition(
+        impact_id="impact_068_confirmed",
+        action="confirmed",
+        title="Confirmed decision impact",
+        tone="positive",
+        summary_template="Choosing confirmed changes how this reason can support future recall.",
+        recall_effect="Future answers will treat this source according to the confirmed decision.",
+        graph_effect="The graph keeps traceability while the trust status changes to confirmed.",
+        open_loop_effect="Open loops are preserved unless the user separately resolves them.",
+        user_pressure="Keep this preview to one sentence by default.",
+        warnings=("Only confirm when the saved reason matches user intent.",),
+        confirmation_question="Is confirmed the decision the user would stand behind later?",
+        next_step="Apply confirmed only after the evidence summary is readable.",
+    ),
+    DecisionImpactDefinition(
+        impact_id="impact_069_rewritten",
+        action="rewritten",
+        title="Rewritten decision impact",
+        tone="constructive",
+        summary_template="Choosing rewritten changes how this reason can support future recall.",
+        recall_effect="Future answers will treat this source according to the rewritten decision.",
+        graph_effect="The graph keeps traceability while the trust status changes to rewritten.",
+        open_loop_effect="Open loops are preserved unless the user separately resolves them.",
+        user_pressure="Keep this preview to one sentence by default.",
+        warnings=("Rewrite should replace the reason without deleting traceability.",),
+        confirmation_question="Is rewritten the decision the user would stand behind later?",
+        next_step="Apply rewritten only after the evidence summary is readable.",
+    ),
+    DecisionImpactDefinition(
+        impact_id="impact_070_rejected",
+        action="rejected",
+        title="Rejected decision impact",
+        tone="danger",
+        summary_template="Choosing rejected changes how this reason can support future recall.",
+        recall_effect="Future answers will treat this source according to the rejected decision.",
+        graph_effect="The graph keeps traceability while the trust status changes to rejected.",
+        open_loop_effect="Open loops are preserved unless the user separately resolves them.",
+        user_pressure="Keep this preview to one sentence by default.",
+        warnings=("Rejected context should not be reused as a trusted reason.",),
+        confirmation_question="Is rejected the decision the user would stand behind later?",
+        next_step="Apply rejected only after the evidence summary is readable.",
+    ),
+    DecisionImpactDefinition(
+        impact_id="impact_071_deferred",
+        action="deferred",
+        title="Deferred decision impact",
+        tone="neutral",
+        summary_template="Choosing deferred changes how this reason can support future recall.",
+        recall_effect="Future answers will treat this source according to the deferred decision.",
+        graph_effect="The graph keeps traceability while the trust status changes to deferred.",
+        open_loop_effect="Open loops are preserved unless the user separately resolves them.",
+        user_pressure="Keep this preview to one sentence by default.",
+        warnings=("Deferred items remain visible in future review sessions.",),
+        confirmation_question="Is deferred the decision the user would stand behind later?",
+        next_step="Apply deferred only after the evidence summary is readable.",
+    ),
+    DecisionImpactDefinition(
+        impact_id="impact_072_confirmed",
+        action="confirmed",
+        title="Confirmed decision impact",
+        tone="positive",
+        summary_template="Choosing confirmed changes how this reason can support future recall.",
+        recall_effect="Future answers will treat this source according to the confirmed decision.",
+        graph_effect="The graph keeps traceability while the trust status changes to confirmed.",
+        open_loop_effect="Open loops are preserved unless the user separately resolves them.",
+        user_pressure="Keep this preview to one sentence by default.",
+        warnings=("Only confirm when the saved reason matches user intent.",),
+        confirmation_question="Is confirmed the decision the user would stand behind later?",
+        next_step="Apply confirmed only after the evidence summary is readable.",
+    ),
+    DecisionImpactDefinition(
+        impact_id="impact_073_rewritten",
+        action="rewritten",
+        title="Rewritten decision impact",
+        tone="constructive",
+        summary_template="Choosing rewritten changes how this reason can support future recall.",
+        recall_effect="Future answers will treat this source according to the rewritten decision.",
+        graph_effect="The graph keeps traceability while the trust status changes to rewritten.",
+        open_loop_effect="Open loops are preserved unless the user separately resolves them.",
+        user_pressure="Keep this preview to one sentence by default.",
+        warnings=("Rewrite should replace the reason without deleting traceability.",),
+        confirmation_question="Is rewritten the decision the user would stand behind later?",
+        next_step="Apply rewritten only after the evidence summary is readable.",
+    ),
+    DecisionImpactDefinition(
+        impact_id="impact_074_rejected",
+        action="rejected",
+        title="Rejected decision impact",
+        tone="danger",
+        summary_template="Choosing rejected changes how this reason can support future recall.",
+        recall_effect="Future answers will treat this source according to the rejected decision.",
+        graph_effect="The graph keeps traceability while the trust status changes to rejected.",
+        open_loop_effect="Open loops are preserved unless the user separately resolves them.",
+        user_pressure="Keep this preview to one sentence by default.",
+        warnings=("Rejected context should not be reused as a trusted reason.",),
+        confirmation_question="Is rejected the decision the user would stand behind later?",
+        next_step="Apply rejected only after the evidence summary is readable.",
+    ),
+    DecisionImpactDefinition(
+        impact_id="impact_075_deferred",
+        action="deferred",
+        title="Deferred decision impact",
+        tone="neutral",
+        summary_template="Choosing deferred changes how this reason can support future recall.",
+        recall_effect="Future answers will treat this source according to the deferred decision.",
+        graph_effect="The graph keeps traceability while the trust status changes to deferred.",
+        open_loop_effect="Open loops are preserved unless the user separately resolves them.",
+        user_pressure="Keep this preview to one sentence by default.",
+        warnings=("Deferred items remain visible in future review sessions.",),
+        confirmation_question="Is deferred the decision the user would stand behind later?",
+        next_step="Apply deferred only after the evidence summary is readable.",
+    ),
+    DecisionImpactDefinition(
+        impact_id="impact_076_confirmed",
+        action="confirmed",
+        title="Confirmed decision impact",
+        tone="positive",
+        summary_template="Choosing confirmed changes how this reason can support future recall.",
+        recall_effect="Future answers will treat this source according to the confirmed decision.",
+        graph_effect="The graph keeps traceability while the trust status changes to confirmed.",
+        open_loop_effect="Open loops are preserved unless the user separately resolves them.",
+        user_pressure="Keep this preview to one sentence by default.",
+        warnings=("Only confirm when the saved reason matches user intent.",),
+        confirmation_question="Is confirmed the decision the user would stand behind later?",
+        next_step="Apply confirmed only after the evidence summary is readable.",
+    ),
+    DecisionImpactDefinition(
+        impact_id="impact_077_rewritten",
+        action="rewritten",
+        title="Rewritten decision impact",
+        tone="constructive",
+        summary_template="Choosing rewritten changes how this reason can support future recall.",
+        recall_effect="Future answers will treat this source according to the rewritten decision.",
+        graph_effect="The graph keeps traceability while the trust status changes to rewritten.",
+        open_loop_effect="Open loops are preserved unless the user separately resolves them.",
+        user_pressure="Keep this preview to one sentence by default.",
+        warnings=("Rewrite should replace the reason without deleting traceability.",),
+        confirmation_question="Is rewritten the decision the user would stand behind later?",
+        next_step="Apply rewritten only after the evidence summary is readable.",
+    ),
+    DecisionImpactDefinition(
+        impact_id="impact_078_rejected",
+        action="rejected",
+        title="Rejected decision impact",
+        tone="danger",
+        summary_template="Choosing rejected changes how this reason can support future recall.",
+        recall_effect="Future answers will treat this source according to the rejected decision.",
+        graph_effect="The graph keeps traceability while the trust status changes to rejected.",
+        open_loop_effect="Open loops are preserved unless the user separately resolves them.",
+        user_pressure="Keep this preview to one sentence by default.",
+        warnings=("Rejected context should not be reused as a trusted reason.",),
+        confirmation_question="Is rejected the decision the user would stand behind later?",
+        next_step="Apply rejected only after the evidence summary is readable.",
+    ),
+    DecisionImpactDefinition(
+        impact_id="impact_079_deferred",
+        action="deferred",
+        title="Deferred decision impact",
+        tone="neutral",
+        summary_template="Choosing deferred changes how this reason can support future recall.",
+        recall_effect="Future answers will treat this source according to the deferred decision.",
+        graph_effect="The graph keeps traceability while the trust status changes to deferred.",
+        open_loop_effect="Open loops are preserved unless the user separately resolves them.",
+        user_pressure="Keep this preview to one sentence by default.",
+        warnings=("Deferred items remain visible in future review sessions.",),
+        confirmation_question="Is deferred the decision the user would stand behind later?",
+        next_step="Apply deferred only after the evidence summary is readable.",
+    ),
+    DecisionImpactDefinition(
+        impact_id="impact_080_confirmed",
+        action="confirmed",
+        title="Confirmed decision impact",
+        tone="positive",
+        summary_template="Choosing confirmed changes how this reason can support future recall.",
+        recall_effect="Future answers will treat this source according to the confirmed decision.",
+        graph_effect="The graph keeps traceability while the trust status changes to confirmed.",
+        open_loop_effect="Open loops are preserved unless the user separately resolves them.",
+        user_pressure="Keep this preview to one sentence by default.",
+        warnings=("Only confirm when the saved reason matches user intent.",),
+        confirmation_question="Is confirmed the decision the user would stand behind later?",
+        next_step="Apply confirmed only after the evidence summary is readable.",
+    ),
+    DecisionImpactDefinition(
+        impact_id="impact_081_rewritten",
+        action="rewritten",
+        title="Rewritten decision impact",
+        tone="constructive",
+        summary_template="Choosing rewritten changes how this reason can support future recall.",
+        recall_effect="Future answers will treat this source according to the rewritten decision.",
+        graph_effect="The graph keeps traceability while the trust status changes to rewritten.",
+        open_loop_effect="Open loops are preserved unless the user separately resolves them.",
+        user_pressure="Keep this preview to one sentence by default.",
+        warnings=("Rewrite should replace the reason without deleting traceability.",),
+        confirmation_question="Is rewritten the decision the user would stand behind later?",
+        next_step="Apply rewritten only after the evidence summary is readable.",
+    ),
+    DecisionImpactDefinition(
+        impact_id="impact_082_rejected",
+        action="rejected",
+        title="Rejected decision impact",
+        tone="danger",
+        summary_template="Choosing rejected changes how this reason can support future recall.",
+        recall_effect="Future answers will treat this source according to the rejected decision.",
+        graph_effect="The graph keeps traceability while the trust status changes to rejected.",
+        open_loop_effect="Open loops are preserved unless the user separately resolves them.",
+        user_pressure="Keep this preview to one sentence by default.",
+        warnings=("Rejected context should not be reused as a trusted reason.",),
+        confirmation_question="Is rejected the decision the user would stand behind later?",
+        next_step="Apply rejected only after the evidence summary is readable.",
+    ),
+    DecisionImpactDefinition(
+        impact_id="impact_083_deferred",
+        action="deferred",
+        title="Deferred decision impact",
+        tone="neutral",
+        summary_template="Choosing deferred changes how this reason can support future recall.",
+        recall_effect="Future answers will treat this source according to the deferred decision.",
+        graph_effect="The graph keeps traceability while the trust status changes to deferred.",
+        open_loop_effect="Open loops are preserved unless the user separately resolves them.",
+        user_pressure="Keep this preview to one sentence by default.",
+        warnings=("Deferred items remain visible in future review sessions.",),
+        confirmation_question="Is deferred the decision the user would stand behind later?",
+        next_step="Apply deferred only after the evidence summary is readable.",
+    ),
+    DecisionImpactDefinition(
+        impact_id="impact_084_confirmed",
+        action="confirmed",
+        title="Confirmed decision impact",
+        tone="positive",
+        summary_template="Choosing confirmed changes how this reason can support future recall.",
+        recall_effect="Future answers will treat this source according to the confirmed decision.",
+        graph_effect="The graph keeps traceability while the trust status changes to confirmed.",
+        open_loop_effect="Open loops are preserved unless the user separately resolves them.",
+        user_pressure="Keep this preview to one sentence by default.",
+        warnings=("Only confirm when the saved reason matches user intent.",),
+        confirmation_question="Is confirmed the decision the user would stand behind later?",
+        next_step="Apply confirmed only after the evidence summary is readable.",
+    ),
+    DecisionImpactDefinition(
+        impact_id="impact_085_rewritten",
+        action="rewritten",
+        title="Rewritten decision impact",
+        tone="constructive",
+        summary_template="Choosing rewritten changes how this reason can support future recall.",
+        recall_effect="Future answers will treat this source according to the rewritten decision.",
+        graph_effect="The graph keeps traceability while the trust status changes to rewritten.",
+        open_loop_effect="Open loops are preserved unless the user separately resolves them.",
+        user_pressure="Keep this preview to one sentence by default.",
+        warnings=("Rewrite should replace the reason without deleting traceability.",),
+        confirmation_question="Is rewritten the decision the user would stand behind later?",
+        next_step="Apply rewritten only after the evidence summary is readable.",
+    ),
+    DecisionImpactDefinition(
+        impact_id="impact_086_rejected",
+        action="rejected",
+        title="Rejected decision impact",
+        tone="danger",
+        summary_template="Choosing rejected changes how this reason can support future recall.",
+        recall_effect="Future answers will treat this source according to the rejected decision.",
+        graph_effect="The graph keeps traceability while the trust status changes to rejected.",
+        open_loop_effect="Open loops are preserved unless the user separately resolves them.",
+        user_pressure="Keep this preview to one sentence by default.",
+        warnings=("Rejected context should not be reused as a trusted reason.",),
+        confirmation_question="Is rejected the decision the user would stand behind later?",
+        next_step="Apply rejected only after the evidence summary is readable.",
+    ),
+    DecisionImpactDefinition(
+        impact_id="impact_087_deferred",
+        action="deferred",
+        title="Deferred decision impact",
+        tone="neutral",
+        summary_template="Choosing deferred changes how this reason can support future recall.",
+        recall_effect="Future answers will treat this source according to the deferred decision.",
+        graph_effect="The graph keeps traceability while the trust status changes to deferred.",
+        open_loop_effect="Open loops are preserved unless the user separately resolves them.",
+        user_pressure="Keep this preview to one sentence by default.",
+        warnings=("Deferred items remain visible in future review sessions.",),
+        confirmation_question="Is deferred the decision the user would stand behind later?",
+        next_step="Apply deferred only after the evidence summary is readable.",
+    ),
+    DecisionImpactDefinition(
+        impact_id="impact_088_confirmed",
+        action="confirmed",
+        title="Confirmed decision impact",
+        tone="positive",
+        summary_template="Choosing confirmed changes how this reason can support future recall.",
+        recall_effect="Future answers will treat this source according to the confirmed decision.",
+        graph_effect="The graph keeps traceability while the trust status changes to confirmed.",
+        open_loop_effect="Open loops are preserved unless the user separately resolves them.",
+        user_pressure="Keep this preview to one sentence by default.",
+        warnings=("Only confirm when the saved reason matches user intent.",),
+        confirmation_question="Is confirmed the decision the user would stand behind later?",
+        next_step="Apply confirmed only after the evidence summary is readable.",
+    ),
+    DecisionImpactDefinition(
+        impact_id="impact_089_rewritten",
+        action="rewritten",
+        title="Rewritten decision impact",
+        tone="constructive",
+        summary_template="Choosing rewritten changes how this reason can support future recall.",
+        recall_effect="Future answers will treat this source according to the rewritten decision.",
+        graph_effect="The graph keeps traceability while the trust status changes to rewritten.",
+        open_loop_effect="Open loops are preserved unless the user separately resolves them.",
+        user_pressure="Keep this preview to one sentence by default.",
+        warnings=("Rewrite should replace the reason without deleting traceability.",),
+        confirmation_question="Is rewritten the decision the user would stand behind later?",
+        next_step="Apply rewritten only after the evidence summary is readable.",
+    ),
+    DecisionImpactDefinition(
+        impact_id="impact_090_rejected",
+        action="rejected",
+        title="Rejected decision impact",
+        tone="danger",
+        summary_template="Choosing rejected changes how this reason can support future recall.",
+        recall_effect="Future answers will treat this source according to the rejected decision.",
+        graph_effect="The graph keeps traceability while the trust status changes to rejected.",
+        open_loop_effect="Open loops are preserved unless the user separately resolves them.",
+        user_pressure="Keep this preview to one sentence by default.",
+        warnings=("Rejected context should not be reused as a trusted reason.",),
+        confirmation_question="Is rejected the decision the user would stand behind later?",
+        next_step="Apply rejected only after the evidence summary is readable.",
+    ),
+    DecisionImpactDefinition(
+        impact_id="impact_091_deferred",
+        action="deferred",
+        title="Deferred decision impact",
+        tone="neutral",
+        summary_template="Choosing deferred changes how this reason can support future recall.",
+        recall_effect="Future answers will treat this source according to the deferred decision.",
+        graph_effect="The graph keeps traceability while the trust status changes to deferred.",
+        open_loop_effect="Open loops are preserved unless the user separately resolves them.",
+        user_pressure="Keep this preview to one sentence by default.",
+        warnings=("Deferred items remain visible in future review sessions.",),
+        confirmation_question="Is deferred the decision the user would stand behind later?",
+        next_step="Apply deferred only after the evidence summary is readable.",
+    ),
+    DecisionImpactDefinition(
+        impact_id="impact_092_confirmed",
+        action="confirmed",
+        title="Confirmed decision impact",
+        tone="positive",
+        summary_template="Choosing confirmed changes how this reason can support future recall.",
+        recall_effect="Future answers will treat this source according to the confirmed decision.",
+        graph_effect="The graph keeps traceability while the trust status changes to confirmed.",
+        open_loop_effect="Open loops are preserved unless the user separately resolves them.",
+        user_pressure="Keep this preview to one sentence by default.",
+        warnings=("Only confirm when the saved reason matches user intent.",),
+        confirmation_question="Is confirmed the decision the user would stand behind later?",
+        next_step="Apply confirmed only after the evidence summary is readable.",
+    ),
+    DecisionImpactDefinition(
+        impact_id="impact_093_rewritten",
+        action="rewritten",
+        title="Rewritten decision impact",
+        tone="constructive",
+        summary_template="Choosing rewritten changes how this reason can support future recall.",
+        recall_effect="Future answers will treat this source according to the rewritten decision.",
+        graph_effect="The graph keeps traceability while the trust status changes to rewritten.",
+        open_loop_effect="Open loops are preserved unless the user separately resolves them.",
+        user_pressure="Keep this preview to one sentence by default.",
+        warnings=("Rewrite should replace the reason without deleting traceability.",),
+        confirmation_question="Is rewritten the decision the user would stand behind later?",
+        next_step="Apply rewritten only after the evidence summary is readable.",
+    ),
+    DecisionImpactDefinition(
+        impact_id="impact_094_rejected",
+        action="rejected",
+        title="Rejected decision impact",
+        tone="danger",
+        summary_template="Choosing rejected changes how this reason can support future recall.",
+        recall_effect="Future answers will treat this source according to the rejected decision.",
+        graph_effect="The graph keeps traceability while the trust status changes to rejected.",
+        open_loop_effect="Open loops are preserved unless the user separately resolves them.",
+        user_pressure="Keep this preview to one sentence by default.",
+        warnings=("Rejected context should not be reused as a trusted reason.",),
+        confirmation_question="Is rejected the decision the user would stand behind later?",
+        next_step="Apply rejected only after the evidence summary is readable.",
+    ),
+    DecisionImpactDefinition(
+        impact_id="impact_095_deferred",
+        action="deferred",
+        title="Deferred decision impact",
+        tone="neutral",
+        summary_template="Choosing deferred changes how this reason can support future recall.",
+        recall_effect="Future answers will treat this source according to the deferred decision.",
+        graph_effect="The graph keeps traceability while the trust status changes to deferred.",
+        open_loop_effect="Open loops are preserved unless the user separately resolves them.",
+        user_pressure="Keep this preview to one sentence by default.",
+        warnings=("Deferred items remain visible in future review sessions.",),
+        confirmation_question="Is deferred the decision the user would stand behind later?",
+        next_step="Apply deferred only after the evidence summary is readable.",
+    ),
+)
+
+REVIEW_PATH_TEMPLATES: tuple[ReviewPathTemplate, ...] = (
+    ReviewPathTemplate(
+        template_id="rpath_000_orient",
+        stage="orient",
+        label="Orient to the saved reason",
+        trigger="orient",
+        instruction="Handle orient with one compact user-facing sentence.",
+        evidence_hint="Use evidence paths only when they reduce uncertainty.",
+        completion_signal="The reviewer can explain why the next action is safe.",
+        fallback_action="defer",
+        quiet_copy="Keep orient collapsed unless it is the current step.",
+        metric_key="orient_count",
+    ),
+    ReviewPathTemplate(
+        template_id="rpath_001_evidence",
+        stage="evidence",
+        label="Scan compressed evidence",
+        trigger="evidence",
+        instruction="Handle evidence with one compact user-facing sentence.",
+        evidence_hint="Use evidence paths only when they reduce uncertainty.",
+        completion_signal="The reviewer can explain why the next action is safe.",
+        fallback_action="defer",
+        quiet_copy="Keep evidence collapsed unless it is the current step.",
+        metric_key="evidence_count",
+    ),
+    ReviewPathTemplate(
+        template_id="rpath_002_conflict",
+        stage="conflict",
+        label="Check uncertainty",
+        trigger="conflict",
+        instruction="Handle conflict with one compact user-facing sentence.",
+        evidence_hint="Use evidence paths only when they reduce uncertainty.",
+        completion_signal="The reviewer can explain why the next action is safe.",
+        fallback_action="defer",
+        quiet_copy="Keep conflict collapsed unless it is the current step.",
+        metric_key="conflict_count",
+    ),
+    ReviewPathTemplate(
+        template_id="rpath_003_decision",
+        stage="decision",
+        label="Choose action",
+        trigger="decision",
+        instruction="Handle decision with one compact user-facing sentence.",
+        evidence_hint="Use evidence paths only when they reduce uncertainty.",
+        completion_signal="The reviewer can explain why the next action is safe.",
+        fallback_action="defer",
+        quiet_copy="Keep decision collapsed unless it is the current step.",
+        metric_key="decision_count",
+    ),
+    ReviewPathTemplate(
+        template_id="rpath_004_writeback",
+        stage="writeback",
+        label="Record the decision",
+        trigger="writeback",
+        instruction="Handle writeback with one compact user-facing sentence.",
+        evidence_hint="Use evidence paths only when they reduce uncertainty.",
+        completion_signal="The reviewer can explain why the next action is safe.",
+        fallback_action="defer",
+        quiet_copy="Keep writeback collapsed unless it is the current step.",
+        metric_key="writeback_count",
+    ),
+    ReviewPathTemplate(
+        template_id="rpath_005_followup",
+        stage="followup",
+        label="Keep or resolve open loops",
+        trigger="followup",
+        instruction="Handle followup with one compact user-facing sentence.",
+        evidence_hint="Use evidence paths only when they reduce uncertainty.",
+        completion_signal="The reviewer can explain why the next action is safe.",
+        fallback_action="defer",
+        quiet_copy="Keep followup collapsed unless it is the current step.",
+        metric_key="followup_count",
+    ),
+    ReviewPathTemplate(
+        template_id="rpath_006_orient",
+        stage="orient",
+        label="Orient to the saved reason",
+        trigger="orient",
+        instruction="Handle orient with one compact user-facing sentence.",
+        evidence_hint="Use evidence paths only when they reduce uncertainty.",
+        completion_signal="The reviewer can explain why the next action is safe.",
+        fallback_action="defer",
+        quiet_copy="Keep orient collapsed unless it is the current step.",
+        metric_key="orient_count",
+    ),
+    ReviewPathTemplate(
+        template_id="rpath_007_evidence",
+        stage="evidence",
+        label="Scan compressed evidence",
+        trigger="evidence",
+        instruction="Handle evidence with one compact user-facing sentence.",
+        evidence_hint="Use evidence paths only when they reduce uncertainty.",
+        completion_signal="The reviewer can explain why the next action is safe.",
+        fallback_action="defer",
+        quiet_copy="Keep evidence collapsed unless it is the current step.",
+        metric_key="evidence_count",
+    ),
+    ReviewPathTemplate(
+        template_id="rpath_008_conflict",
+        stage="conflict",
+        label="Check uncertainty",
+        trigger="conflict",
+        instruction="Handle conflict with one compact user-facing sentence.",
+        evidence_hint="Use evidence paths only when they reduce uncertainty.",
+        completion_signal="The reviewer can explain why the next action is safe.",
+        fallback_action="defer",
+        quiet_copy="Keep conflict collapsed unless it is the current step.",
+        metric_key="conflict_count",
+    ),
+    ReviewPathTemplate(
+        template_id="rpath_009_decision",
+        stage="decision",
+        label="Choose action",
+        trigger="decision",
+        instruction="Handle decision with one compact user-facing sentence.",
+        evidence_hint="Use evidence paths only when they reduce uncertainty.",
+        completion_signal="The reviewer can explain why the next action is safe.",
+        fallback_action="defer",
+        quiet_copy="Keep decision collapsed unless it is the current step.",
+        metric_key="decision_count",
+    ),
+    ReviewPathTemplate(
+        template_id="rpath_010_writeback",
+        stage="writeback",
+        label="Record the decision",
+        trigger="writeback",
+        instruction="Handle writeback with one compact user-facing sentence.",
+        evidence_hint="Use evidence paths only when they reduce uncertainty.",
+        completion_signal="The reviewer can explain why the next action is safe.",
+        fallback_action="defer",
+        quiet_copy="Keep writeback collapsed unless it is the current step.",
+        metric_key="writeback_count",
+    ),
+    ReviewPathTemplate(
+        template_id="rpath_011_followup",
+        stage="followup",
+        label="Keep or resolve open loops",
+        trigger="followup",
+        instruction="Handle followup with one compact user-facing sentence.",
+        evidence_hint="Use evidence paths only when they reduce uncertainty.",
+        completion_signal="The reviewer can explain why the next action is safe.",
+        fallback_action="defer",
+        quiet_copy="Keep followup collapsed unless it is the current step.",
+        metric_key="followup_count",
+    ),
+    ReviewPathTemplate(
+        template_id="rpath_012_orient",
+        stage="orient",
+        label="Orient to the saved reason",
+        trigger="orient",
+        instruction="Handle orient with one compact user-facing sentence.",
+        evidence_hint="Use evidence paths only when they reduce uncertainty.",
+        completion_signal="The reviewer can explain why the next action is safe.",
+        fallback_action="defer",
+        quiet_copy="Keep orient collapsed unless it is the current step.",
+        metric_key="orient_count",
+    ),
+    ReviewPathTemplate(
+        template_id="rpath_013_evidence",
+        stage="evidence",
+        label="Scan compressed evidence",
+        trigger="evidence",
+        instruction="Handle evidence with one compact user-facing sentence.",
+        evidence_hint="Use evidence paths only when they reduce uncertainty.",
+        completion_signal="The reviewer can explain why the next action is safe.",
+        fallback_action="defer",
+        quiet_copy="Keep evidence collapsed unless it is the current step.",
+        metric_key="evidence_count",
+    ),
+    ReviewPathTemplate(
+        template_id="rpath_014_conflict",
+        stage="conflict",
+        label="Check uncertainty",
+        trigger="conflict",
+        instruction="Handle conflict with one compact user-facing sentence.",
+        evidence_hint="Use evidence paths only when they reduce uncertainty.",
+        completion_signal="The reviewer can explain why the next action is safe.",
+        fallback_action="defer",
+        quiet_copy="Keep conflict collapsed unless it is the current step.",
+        metric_key="conflict_count",
+    ),
+    ReviewPathTemplate(
+        template_id="rpath_015_decision",
+        stage="decision",
+        label="Choose action",
+        trigger="decision",
+        instruction="Handle decision with one compact user-facing sentence.",
+        evidence_hint="Use evidence paths only when they reduce uncertainty.",
+        completion_signal="The reviewer can explain why the next action is safe.",
+        fallback_action="defer",
+        quiet_copy="Keep decision collapsed unless it is the current step.",
+        metric_key="decision_count",
+    ),
+    ReviewPathTemplate(
+        template_id="rpath_016_writeback",
+        stage="writeback",
+        label="Record the decision",
+        trigger="writeback",
+        instruction="Handle writeback with one compact user-facing sentence.",
+        evidence_hint="Use evidence paths only when they reduce uncertainty.",
+        completion_signal="The reviewer can explain why the next action is safe.",
+        fallback_action="defer",
+        quiet_copy="Keep writeback collapsed unless it is the current step.",
+        metric_key="writeback_count",
+    ),
+    ReviewPathTemplate(
+        template_id="rpath_017_followup",
+        stage="followup",
+        label="Keep or resolve open loops",
+        trigger="followup",
+        instruction="Handle followup with one compact user-facing sentence.",
+        evidence_hint="Use evidence paths only when they reduce uncertainty.",
+        completion_signal="The reviewer can explain why the next action is safe.",
+        fallback_action="defer",
+        quiet_copy="Keep followup collapsed unless it is the current step.",
+        metric_key="followup_count",
+    ),
+    ReviewPathTemplate(
+        template_id="rpath_018_orient",
+        stage="orient",
+        label="Orient to the saved reason",
+        trigger="orient",
+        instruction="Handle orient with one compact user-facing sentence.",
+        evidence_hint="Use evidence paths only when they reduce uncertainty.",
+        completion_signal="The reviewer can explain why the next action is safe.",
+        fallback_action="defer",
+        quiet_copy="Keep orient collapsed unless it is the current step.",
+        metric_key="orient_count",
+    ),
+    ReviewPathTemplate(
+        template_id="rpath_019_evidence",
+        stage="evidence",
+        label="Scan compressed evidence",
+        trigger="evidence",
+        instruction="Handle evidence with one compact user-facing sentence.",
+        evidence_hint="Use evidence paths only when they reduce uncertainty.",
+        completion_signal="The reviewer can explain why the next action is safe.",
+        fallback_action="defer",
+        quiet_copy="Keep evidence collapsed unless it is the current step.",
+        metric_key="evidence_count",
+    ),
+    ReviewPathTemplate(
+        template_id="rpath_020_conflict",
+        stage="conflict",
+        label="Check uncertainty",
+        trigger="conflict",
+        instruction="Handle conflict with one compact user-facing sentence.",
+        evidence_hint="Use evidence paths only when they reduce uncertainty.",
+        completion_signal="The reviewer can explain why the next action is safe.",
+        fallback_action="defer",
+        quiet_copy="Keep conflict collapsed unless it is the current step.",
+        metric_key="conflict_count",
+    ),
+    ReviewPathTemplate(
+        template_id="rpath_021_decision",
+        stage="decision",
+        label="Choose action",
+        trigger="decision",
+        instruction="Handle decision with one compact user-facing sentence.",
+        evidence_hint="Use evidence paths only when they reduce uncertainty.",
+        completion_signal="The reviewer can explain why the next action is safe.",
+        fallback_action="defer",
+        quiet_copy="Keep decision collapsed unless it is the current step.",
+        metric_key="decision_count",
+    ),
+    ReviewPathTemplate(
+        template_id="rpath_022_writeback",
+        stage="writeback",
+        label="Record the decision",
+        trigger="writeback",
+        instruction="Handle writeback with one compact user-facing sentence.",
+        evidence_hint="Use evidence paths only when they reduce uncertainty.",
+        completion_signal="The reviewer can explain why the next action is safe.",
+        fallback_action="defer",
+        quiet_copy="Keep writeback collapsed unless it is the current step.",
+        metric_key="writeback_count",
+    ),
+    ReviewPathTemplate(
+        template_id="rpath_023_followup",
+        stage="followup",
+        label="Keep or resolve open loops",
+        trigger="followup",
+        instruction="Handle followup with one compact user-facing sentence.",
+        evidence_hint="Use evidence paths only when they reduce uncertainty.",
+        completion_signal="The reviewer can explain why the next action is safe.",
+        fallback_action="defer",
+        quiet_copy="Keep followup collapsed unless it is the current step.",
+        metric_key="followup_count",
+    ),
+    ReviewPathTemplate(
+        template_id="rpath_024_orient",
+        stage="orient",
+        label="Orient to the saved reason",
+        trigger="orient",
+        instruction="Handle orient with one compact user-facing sentence.",
+        evidence_hint="Use evidence paths only when they reduce uncertainty.",
+        completion_signal="The reviewer can explain why the next action is safe.",
+        fallback_action="defer",
+        quiet_copy="Keep orient collapsed unless it is the current step.",
+        metric_key="orient_count",
+    ),
+    ReviewPathTemplate(
+        template_id="rpath_025_evidence",
+        stage="evidence",
+        label="Scan compressed evidence",
+        trigger="evidence",
+        instruction="Handle evidence with one compact user-facing sentence.",
+        evidence_hint="Use evidence paths only when they reduce uncertainty.",
+        completion_signal="The reviewer can explain why the next action is safe.",
+        fallback_action="defer",
+        quiet_copy="Keep evidence collapsed unless it is the current step.",
+        metric_key="evidence_count",
+    ),
+    ReviewPathTemplate(
+        template_id="rpath_026_conflict",
+        stage="conflict",
+        label="Check uncertainty",
+        trigger="conflict",
+        instruction="Handle conflict with one compact user-facing sentence.",
+        evidence_hint="Use evidence paths only when they reduce uncertainty.",
+        completion_signal="The reviewer can explain why the next action is safe.",
+        fallback_action="defer",
+        quiet_copy="Keep conflict collapsed unless it is the current step.",
+        metric_key="conflict_count",
+    ),
+    ReviewPathTemplate(
+        template_id="rpath_027_decision",
+        stage="decision",
+        label="Choose action",
+        trigger="decision",
+        instruction="Handle decision with one compact user-facing sentence.",
+        evidence_hint="Use evidence paths only when they reduce uncertainty.",
+        completion_signal="The reviewer can explain why the next action is safe.",
+        fallback_action="defer",
+        quiet_copy="Keep decision collapsed unless it is the current step.",
+        metric_key="decision_count",
+    ),
+    ReviewPathTemplate(
+        template_id="rpath_028_writeback",
+        stage="writeback",
+        label="Record the decision",
+        trigger="writeback",
+        instruction="Handle writeback with one compact user-facing sentence.",
+        evidence_hint="Use evidence paths only when they reduce uncertainty.",
+        completion_signal="The reviewer can explain why the next action is safe.",
+        fallback_action="defer",
+        quiet_copy="Keep writeback collapsed unless it is the current step.",
+        metric_key="writeback_count",
+    ),
+    ReviewPathTemplate(
+        template_id="rpath_029_followup",
+        stage="followup",
+        label="Keep or resolve open loops",
+        trigger="followup",
+        instruction="Handle followup with one compact user-facing sentence.",
+        evidence_hint="Use evidence paths only when they reduce uncertainty.",
+        completion_signal="The reviewer can explain why the next action is safe.",
+        fallback_action="defer",
+        quiet_copy="Keep followup collapsed unless it is the current step.",
+        metric_key="followup_count",
+    ),
+    ReviewPathTemplate(
+        template_id="rpath_030_orient",
+        stage="orient",
+        label="Orient to the saved reason",
+        trigger="orient",
+        instruction="Handle orient with one compact user-facing sentence.",
+        evidence_hint="Use evidence paths only when they reduce uncertainty.",
+        completion_signal="The reviewer can explain why the next action is safe.",
+        fallback_action="defer",
+        quiet_copy="Keep orient collapsed unless it is the current step.",
+        metric_key="orient_count",
+    ),
+    ReviewPathTemplate(
+        template_id="rpath_031_evidence",
+        stage="evidence",
+        label="Scan compressed evidence",
+        trigger="evidence",
+        instruction="Handle evidence with one compact user-facing sentence.",
+        evidence_hint="Use evidence paths only when they reduce uncertainty.",
+        completion_signal="The reviewer can explain why the next action is safe.",
+        fallback_action="defer",
+        quiet_copy="Keep evidence collapsed unless it is the current step.",
+        metric_key="evidence_count",
+    ),
+    ReviewPathTemplate(
+        template_id="rpath_032_conflict",
+        stage="conflict",
+        label="Check uncertainty",
+        trigger="conflict",
+        instruction="Handle conflict with one compact user-facing sentence.",
+        evidence_hint="Use evidence paths only when they reduce uncertainty.",
+        completion_signal="The reviewer can explain why the next action is safe.",
+        fallback_action="defer",
+        quiet_copy="Keep conflict collapsed unless it is the current step.",
+        metric_key="conflict_count",
+    ),
+    ReviewPathTemplate(
+        template_id="rpath_033_decision",
+        stage="decision",
+        label="Choose action",
+        trigger="decision",
+        instruction="Handle decision with one compact user-facing sentence.",
+        evidence_hint="Use evidence paths only when they reduce uncertainty.",
+        completion_signal="The reviewer can explain why the next action is safe.",
+        fallback_action="defer",
+        quiet_copy="Keep decision collapsed unless it is the current step.",
+        metric_key="decision_count",
+    ),
+    ReviewPathTemplate(
+        template_id="rpath_034_writeback",
+        stage="writeback",
+        label="Record the decision",
+        trigger="writeback",
+        instruction="Handle writeback with one compact user-facing sentence.",
+        evidence_hint="Use evidence paths only when they reduce uncertainty.",
+        completion_signal="The reviewer can explain why the next action is safe.",
+        fallback_action="defer",
+        quiet_copy="Keep writeback collapsed unless it is the current step.",
+        metric_key="writeback_count",
+    ),
+    ReviewPathTemplate(
+        template_id="rpath_035_followup",
+        stage="followup",
+        label="Keep or resolve open loops",
+        trigger="followup",
+        instruction="Handle followup with one compact user-facing sentence.",
+        evidence_hint="Use evidence paths only when they reduce uncertainty.",
+        completion_signal="The reviewer can explain why the next action is safe.",
+        fallback_action="defer",
+        quiet_copy="Keep followup collapsed unless it is the current step.",
+        metric_key="followup_count",
+    ),
+    ReviewPathTemplate(
+        template_id="rpath_036_orient",
+        stage="orient",
+        label="Orient to the saved reason",
+        trigger="orient",
+        instruction="Handle orient with one compact user-facing sentence.",
+        evidence_hint="Use evidence paths only when they reduce uncertainty.",
+        completion_signal="The reviewer can explain why the next action is safe.",
+        fallback_action="defer",
+        quiet_copy="Keep orient collapsed unless it is the current step.",
+        metric_key="orient_count",
+    ),
+    ReviewPathTemplate(
+        template_id="rpath_037_evidence",
+        stage="evidence",
+        label="Scan compressed evidence",
+        trigger="evidence",
+        instruction="Handle evidence with one compact user-facing sentence.",
+        evidence_hint="Use evidence paths only when they reduce uncertainty.",
+        completion_signal="The reviewer can explain why the next action is safe.",
+        fallback_action="defer",
+        quiet_copy="Keep evidence collapsed unless it is the current step.",
+        metric_key="evidence_count",
+    ),
+    ReviewPathTemplate(
+        template_id="rpath_038_conflict",
+        stage="conflict",
+        label="Check uncertainty",
+        trigger="conflict",
+        instruction="Handle conflict with one compact user-facing sentence.",
+        evidence_hint="Use evidence paths only when they reduce uncertainty.",
+        completion_signal="The reviewer can explain why the next action is safe.",
+        fallback_action="defer",
+        quiet_copy="Keep conflict collapsed unless it is the current step.",
+        metric_key="conflict_count",
+    ),
+    ReviewPathTemplate(
+        template_id="rpath_039_decision",
+        stage="decision",
+        label="Choose action",
+        trigger="decision",
+        instruction="Handle decision with one compact user-facing sentence.",
+        evidence_hint="Use evidence paths only when they reduce uncertainty.",
+        completion_signal="The reviewer can explain why the next action is safe.",
+        fallback_action="defer",
+        quiet_copy="Keep decision collapsed unless it is the current step.",
+        metric_key="decision_count",
+    ),
+    ReviewPathTemplate(
+        template_id="rpath_040_writeback",
+        stage="writeback",
+        label="Record the decision",
+        trigger="writeback",
+        instruction="Handle writeback with one compact user-facing sentence.",
+        evidence_hint="Use evidence paths only when they reduce uncertainty.",
+        completion_signal="The reviewer can explain why the next action is safe.",
+        fallback_action="defer",
+        quiet_copy="Keep writeback collapsed unless it is the current step.",
+        metric_key="writeback_count",
+    ),
+    ReviewPathTemplate(
+        template_id="rpath_041_followup",
+        stage="followup",
+        label="Keep or resolve open loops",
+        trigger="followup",
+        instruction="Handle followup with one compact user-facing sentence.",
+        evidence_hint="Use evidence paths only when they reduce uncertainty.",
+        completion_signal="The reviewer can explain why the next action is safe.",
+        fallback_action="defer",
+        quiet_copy="Keep followup collapsed unless it is the current step.",
+        metric_key="followup_count",
+    ),
+    ReviewPathTemplate(
+        template_id="rpath_042_orient",
+        stage="orient",
+        label="Orient to the saved reason",
+        trigger="orient",
+        instruction="Handle orient with one compact user-facing sentence.",
+        evidence_hint="Use evidence paths only when they reduce uncertainty.",
+        completion_signal="The reviewer can explain why the next action is safe.",
+        fallback_action="defer",
+        quiet_copy="Keep orient collapsed unless it is the current step.",
+        metric_key="orient_count",
+    ),
+    ReviewPathTemplate(
+        template_id="rpath_043_evidence",
+        stage="evidence",
+        label="Scan compressed evidence",
+        trigger="evidence",
+        instruction="Handle evidence with one compact user-facing sentence.",
+        evidence_hint="Use evidence paths only when they reduce uncertainty.",
+        completion_signal="The reviewer can explain why the next action is safe.",
+        fallback_action="defer",
+        quiet_copy="Keep evidence collapsed unless it is the current step.",
+        metric_key="evidence_count",
+    ),
+    ReviewPathTemplate(
+        template_id="rpath_044_conflict",
+        stage="conflict",
+        label="Check uncertainty",
+        trigger="conflict",
+        instruction="Handle conflict with one compact user-facing sentence.",
+        evidence_hint="Use evidence paths only when they reduce uncertainty.",
+        completion_signal="The reviewer can explain why the next action is safe.",
+        fallback_action="defer",
+        quiet_copy="Keep conflict collapsed unless it is the current step.",
+        metric_key="conflict_count",
+    ),
+    ReviewPathTemplate(
+        template_id="rpath_045_decision",
+        stage="decision",
+        label="Choose action",
+        trigger="decision",
+        instruction="Handle decision with one compact user-facing sentence.",
+        evidence_hint="Use evidence paths only when they reduce uncertainty.",
+        completion_signal="The reviewer can explain why the next action is safe.",
+        fallback_action="defer",
+        quiet_copy="Keep decision collapsed unless it is the current step.",
+        metric_key="decision_count",
+    ),
+    ReviewPathTemplate(
+        template_id="rpath_046_writeback",
+        stage="writeback",
+        label="Record the decision",
+        trigger="writeback",
+        instruction="Handle writeback with one compact user-facing sentence.",
+        evidence_hint="Use evidence paths only when they reduce uncertainty.",
+        completion_signal="The reviewer can explain why the next action is safe.",
+        fallback_action="defer",
+        quiet_copy="Keep writeback collapsed unless it is the current step.",
+        metric_key="writeback_count",
+    ),
+    ReviewPathTemplate(
+        template_id="rpath_047_followup",
+        stage="followup",
+        label="Keep or resolve open loops",
+        trigger="followup",
+        instruction="Handle followup with one compact user-facing sentence.",
+        evidence_hint="Use evidence paths only when they reduce uncertainty.",
+        completion_signal="The reviewer can explain why the next action is safe.",
+        fallback_action="defer",
+        quiet_copy="Keep followup collapsed unless it is the current step.",
+        metric_key="followup_count",
+    ),
+    ReviewPathTemplate(
+        template_id="rpath_048_orient",
+        stage="orient",
+        label="Orient to the saved reason",
+        trigger="orient",
+        instruction="Handle orient with one compact user-facing sentence.",
+        evidence_hint="Use evidence paths only when they reduce uncertainty.",
+        completion_signal="The reviewer can explain why the next action is safe.",
+        fallback_action="defer",
+        quiet_copy="Keep orient collapsed unless it is the current step.",
+        metric_key="orient_count",
+    ),
+    ReviewPathTemplate(
+        template_id="rpath_049_evidence",
+        stage="evidence",
+        label="Scan compressed evidence",
+        trigger="evidence",
+        instruction="Handle evidence with one compact user-facing sentence.",
+        evidence_hint="Use evidence paths only when they reduce uncertainty.",
+        completion_signal="The reviewer can explain why the next action is safe.",
+        fallback_action="defer",
+        quiet_copy="Keep evidence collapsed unless it is the current step.",
+        metric_key="evidence_count",
+    ),
+    ReviewPathTemplate(
+        template_id="rpath_050_conflict",
+        stage="conflict",
+        label="Check uncertainty",
+        trigger="conflict",
+        instruction="Handle conflict with one compact user-facing sentence.",
+        evidence_hint="Use evidence paths only when they reduce uncertainty.",
+        completion_signal="The reviewer can explain why the next action is safe.",
+        fallback_action="defer",
+        quiet_copy="Keep conflict collapsed unless it is the current step.",
+        metric_key="conflict_count",
+    ),
+    ReviewPathTemplate(
+        template_id="rpath_051_decision",
+        stage="decision",
+        label="Choose action",
+        trigger="decision",
+        instruction="Handle decision with one compact user-facing sentence.",
+        evidence_hint="Use evidence paths only when they reduce uncertainty.",
+        completion_signal="The reviewer can explain why the next action is safe.",
+        fallback_action="defer",
+        quiet_copy="Keep decision collapsed unless it is the current step.",
+        metric_key="decision_count",
+    ),
+    ReviewPathTemplate(
+        template_id="rpath_052_writeback",
+        stage="writeback",
+        label="Record the decision",
+        trigger="writeback",
+        instruction="Handle writeback with one compact user-facing sentence.",
+        evidence_hint="Use evidence paths only when they reduce uncertainty.",
+        completion_signal="The reviewer can explain why the next action is safe.",
+        fallback_action="defer",
+        quiet_copy="Keep writeback collapsed unless it is the current step.",
+        metric_key="writeback_count",
+    ),
+    ReviewPathTemplate(
+        template_id="rpath_053_followup",
+        stage="followup",
+        label="Keep or resolve open loops",
+        trigger="followup",
+        instruction="Handle followup with one compact user-facing sentence.",
+        evidence_hint="Use evidence paths only when they reduce uncertainty.",
+        completion_signal="The reviewer can explain why the next action is safe.",
+        fallback_action="defer",
+        quiet_copy="Keep followup collapsed unless it is the current step.",
+        metric_key="followup_count",
+    ),
+    ReviewPathTemplate(
+        template_id="rpath_054_orient",
+        stage="orient",
+        label="Orient to the saved reason",
+        trigger="orient",
+        instruction="Handle orient with one compact user-facing sentence.",
+        evidence_hint="Use evidence paths only when they reduce uncertainty.",
+        completion_signal="The reviewer can explain why the next action is safe.",
+        fallback_action="defer",
+        quiet_copy="Keep orient collapsed unless it is the current step.",
+        metric_key="orient_count",
+    ),
+    ReviewPathTemplate(
+        template_id="rpath_055_evidence",
+        stage="evidence",
+        label="Scan compressed evidence",
+        trigger="evidence",
+        instruction="Handle evidence with one compact user-facing sentence.",
+        evidence_hint="Use evidence paths only when they reduce uncertainty.",
+        completion_signal="The reviewer can explain why the next action is safe.",
+        fallback_action="defer",
+        quiet_copy="Keep evidence collapsed unless it is the current step.",
+        metric_key="evidence_count",
+    ),
+    ReviewPathTemplate(
+        template_id="rpath_056_conflict",
+        stage="conflict",
+        label="Check uncertainty",
+        trigger="conflict",
+        instruction="Handle conflict with one compact user-facing sentence.",
+        evidence_hint="Use evidence paths only when they reduce uncertainty.",
+        completion_signal="The reviewer can explain why the next action is safe.",
+        fallback_action="defer",
+        quiet_copy="Keep conflict collapsed unless it is the current step.",
+        metric_key="conflict_count",
+    ),
+    ReviewPathTemplate(
+        template_id="rpath_057_decision",
+        stage="decision",
+        label="Choose action",
+        trigger="decision",
+        instruction="Handle decision with one compact user-facing sentence.",
+        evidence_hint="Use evidence paths only when they reduce uncertainty.",
+        completion_signal="The reviewer can explain why the next action is safe.",
+        fallback_action="defer",
+        quiet_copy="Keep decision collapsed unless it is the current step.",
+        metric_key="decision_count",
+    ),
+    ReviewPathTemplate(
+        template_id="rpath_058_writeback",
+        stage="writeback",
+        label="Record the decision",
+        trigger="writeback",
+        instruction="Handle writeback with one compact user-facing sentence.",
+        evidence_hint="Use evidence paths only when they reduce uncertainty.",
+        completion_signal="The reviewer can explain why the next action is safe.",
+        fallback_action="defer",
+        quiet_copy="Keep writeback collapsed unless it is the current step.",
+        metric_key="writeback_count",
+    ),
+    ReviewPathTemplate(
+        template_id="rpath_059_followup",
+        stage="followup",
+        label="Keep or resolve open loops",
+        trigger="followup",
+        instruction="Handle followup with one compact user-facing sentence.",
+        evidence_hint="Use evidence paths only when they reduce uncertainty.",
+        completion_signal="The reviewer can explain why the next action is safe.",
+        fallback_action="defer",
+        quiet_copy="Keep followup collapsed unless it is the current step.",
+        metric_key="followup_count",
+    ),
+    ReviewPathTemplate(
+        template_id="rpath_060_orient",
+        stage="orient",
+        label="Orient to the saved reason",
+        trigger="orient",
+        instruction="Handle orient with one compact user-facing sentence.",
+        evidence_hint="Use evidence paths only when they reduce uncertainty.",
+        completion_signal="The reviewer can explain why the next action is safe.",
+        fallback_action="defer",
+        quiet_copy="Keep orient collapsed unless it is the current step.",
+        metric_key="orient_count",
+    ),
+    ReviewPathTemplate(
+        template_id="rpath_061_evidence",
+        stage="evidence",
+        label="Scan compressed evidence",
+        trigger="evidence",
+        instruction="Handle evidence with one compact user-facing sentence.",
+        evidence_hint="Use evidence paths only when they reduce uncertainty.",
+        completion_signal="The reviewer can explain why the next action is safe.",
+        fallback_action="defer",
+        quiet_copy="Keep evidence collapsed unless it is the current step.",
+        metric_key="evidence_count",
+    ),
+    ReviewPathTemplate(
+        template_id="rpath_062_conflict",
+        stage="conflict",
+        label="Check uncertainty",
+        trigger="conflict",
+        instruction="Handle conflict with one compact user-facing sentence.",
+        evidence_hint="Use evidence paths only when they reduce uncertainty.",
+        completion_signal="The reviewer can explain why the next action is safe.",
+        fallback_action="defer",
+        quiet_copy="Keep conflict collapsed unless it is the current step.",
+        metric_key="conflict_count",
+    ),
+    ReviewPathTemplate(
+        template_id="rpath_063_decision",
+        stage="decision",
+        label="Choose action",
+        trigger="decision",
+        instruction="Handle decision with one compact user-facing sentence.",
+        evidence_hint="Use evidence paths only when they reduce uncertainty.",
+        completion_signal="The reviewer can explain why the next action is safe.",
+        fallback_action="defer",
+        quiet_copy="Keep decision collapsed unless it is the current step.",
+        metric_key="decision_count",
+    ),
+    ReviewPathTemplate(
+        template_id="rpath_064_writeback",
+        stage="writeback",
+        label="Record the decision",
+        trigger="writeback",
+        instruction="Handle writeback with one compact user-facing sentence.",
+        evidence_hint="Use evidence paths only when they reduce uncertainty.",
+        completion_signal="The reviewer can explain why the next action is safe.",
+        fallback_action="defer",
+        quiet_copy="Keep writeback collapsed unless it is the current step.",
+        metric_key="writeback_count",
+    ),
+    ReviewPathTemplate(
+        template_id="rpath_065_followup",
+        stage="followup",
+        label="Keep or resolve open loops",
+        trigger="followup",
+        instruction="Handle followup with one compact user-facing sentence.",
+        evidence_hint="Use evidence paths only when they reduce uncertainty.",
+        completion_signal="The reviewer can explain why the next action is safe.",
+        fallback_action="defer",
+        quiet_copy="Keep followup collapsed unless it is the current step.",
+        metric_key="followup_count",
+    ),
+    ReviewPathTemplate(
+        template_id="rpath_066_orient",
+        stage="orient",
+        label="Orient to the saved reason",
+        trigger="orient",
+        instruction="Handle orient with one compact user-facing sentence.",
+        evidence_hint="Use evidence paths only when they reduce uncertainty.",
+        completion_signal="The reviewer can explain why the next action is safe.",
+        fallback_action="defer",
+        quiet_copy="Keep orient collapsed unless it is the current step.",
+        metric_key="orient_count",
+    ),
+    ReviewPathTemplate(
+        template_id="rpath_067_evidence",
+        stage="evidence",
+        label="Scan compressed evidence",
+        trigger="evidence",
+        instruction="Handle evidence with one compact user-facing sentence.",
+        evidence_hint="Use evidence paths only when they reduce uncertainty.",
+        completion_signal="The reviewer can explain why the next action is safe.",
+        fallback_action="defer",
+        quiet_copy="Keep evidence collapsed unless it is the current step.",
+        metric_key="evidence_count",
+    ),
+    ReviewPathTemplate(
+        template_id="rpath_068_conflict",
+        stage="conflict",
+        label="Check uncertainty",
+        trigger="conflict",
+        instruction="Handle conflict with one compact user-facing sentence.",
+        evidence_hint="Use evidence paths only when they reduce uncertainty.",
+        completion_signal="The reviewer can explain why the next action is safe.",
+        fallback_action="defer",
+        quiet_copy="Keep conflict collapsed unless it is the current step.",
+        metric_key="conflict_count",
+    ),
+    ReviewPathTemplate(
+        template_id="rpath_069_decision",
+        stage="decision",
+        label="Choose action",
+        trigger="decision",
+        instruction="Handle decision with one compact user-facing sentence.",
+        evidence_hint="Use evidence paths only when they reduce uncertainty.",
+        completion_signal="The reviewer can explain why the next action is safe.",
+        fallback_action="defer",
+        quiet_copy="Keep decision collapsed unless it is the current step.",
+        metric_key="decision_count",
+    ),
+    ReviewPathTemplate(
+        template_id="rpath_070_writeback",
+        stage="writeback",
+        label="Record the decision",
+        trigger="writeback",
+        instruction="Handle writeback with one compact user-facing sentence.",
+        evidence_hint="Use evidence paths only when they reduce uncertainty.",
+        completion_signal="The reviewer can explain why the next action is safe.",
+        fallback_action="defer",
+        quiet_copy="Keep writeback collapsed unless it is the current step.",
+        metric_key="writeback_count",
+    ),
+    ReviewPathTemplate(
+        template_id="rpath_071_followup",
+        stage="followup",
+        label="Keep or resolve open loops",
+        trigger="followup",
+        instruction="Handle followup with one compact user-facing sentence.",
+        evidence_hint="Use evidence paths only when they reduce uncertainty.",
+        completion_signal="The reviewer can explain why the next action is safe.",
+        fallback_action="defer",
+        quiet_copy="Keep followup collapsed unless it is the current step.",
+        metric_key="followup_count",
+    ),
+)
+
+REPORT_SECTION_DEFINITIONS: tuple[ReportSectionDefinition, ...] = (
+    ReportSectionDefinition(
+        section_id="section_000_risk",
+        title="Risk queue",
+        priority=1,
+        trigger="risk",
+        summary_template="Summarize risk queue using counts and one next action.",
+        empty_template="No active risk queue issue needs attention.",
+        metric_key="risk_count",
+        detail_prompt="Expand risk queue only when the reviewer needs proof.",
+        quiet_copy="Keep risk queue as a collapsed report section.",
+        action_label="Review risk queue",
+    ),
+    ReportSectionDefinition(
+        section_id="section_001_ai",
+        title="AI inference debt",
+        priority=2,
+        trigger="ai",
+        summary_template="Summarize ai inference debt using counts and one next action.",
+        empty_template="No active ai inference debt issue needs attention.",
+        metric_key="ai_count",
+        detail_prompt="Expand ai inference debt only when the reviewer needs proof.",
+        quiet_copy="Keep ai inference debt as a collapsed report section.",
+        action_label="Review ai inference debt",
+    ),
+    ReportSectionDefinition(
+        section_id="section_002_evidence",
+        title="Evidence coverage",
+        priority=3,
+        trigger="evidence",
+        summary_template="Summarize evidence coverage using counts and one next action.",
+        empty_template="No active evidence coverage issue needs attention.",
+        metric_key="evidence_count",
+        detail_prompt="Expand evidence coverage only when the reviewer needs proof.",
+        quiet_copy="Keep evidence coverage as a collapsed report section.",
+        action_label="Review evidence coverage",
+    ),
+    ReportSectionDefinition(
+        section_id="section_003_loops",
+        title="Open-loop pressure",
+        priority=4,
+        trigger="loops",
+        summary_template="Summarize open-loop pressure using counts and one next action.",
+        empty_template="No active open-loop pressure issue needs attention.",
+        metric_key="loops_count",
+        detail_prompt="Expand open-loop pressure only when the reviewer needs proof.",
+        quiet_copy="Keep open-loop pressure as a collapsed report section.",
+        action_label="Review open-loop pressure",
+    ),
+    ReportSectionDefinition(
+        section_id="section_004_history",
+        title="Review history",
+        priority=5,
+        trigger="history",
+        summary_template="Summarize review history using counts and one next action.",
+        empty_template="No active review history issue needs attention.",
+        metric_key="history_count",
+        detail_prompt="Expand review history only when the reviewer needs proof.",
+        quiet_copy="Keep review history as a collapsed report section.",
+        action_label="Review review history",
+    ),
+    ReportSectionDefinition(
+        section_id="section_005_topics",
+        title="Topic reuse",
+        priority=6,
+        trigger="topics",
+        summary_template="Summarize topic reuse using counts and one next action.",
+        empty_template="No active topic reuse issue needs attention.",
+        metric_key="topics_count",
+        detail_prompt="Expand topic reuse only when the reviewer needs proof.",
+        quiet_copy="Keep topic reuse as a collapsed report section.",
+        action_label="Review topic reuse",
+    ),
+    ReportSectionDefinition(
+        section_id="section_006_recall",
+        title="Future recall impact",
+        priority=7,
+        trigger="recall",
+        summary_template="Summarize future recall impact using counts and one next action.",
+        empty_template="No active future recall impact issue needs attention.",
+        metric_key="recall_count",
+        detail_prompt="Expand future recall impact only when the reviewer needs proof.",
+        quiet_copy="Keep future recall impact as a collapsed report section.",
+        action_label="Review future recall impact",
+    ),
+    ReportSectionDefinition(
+        section_id="section_007_decisions",
+        title="Decision readiness",
+        priority=8,
+        trigger="decisions",
+        summary_template="Summarize decision readiness using counts and one next action.",
+        empty_template="No active decision readiness issue needs attention.",
+        metric_key="decisions_count",
+        detail_prompt="Expand decision readiness only when the reviewer needs proof.",
+        quiet_copy="Keep decision readiness as a collapsed report section.",
+        action_label="Review decision readiness",
+    ),
+    ReportSectionDefinition(
+        section_id="section_008_traceability",
+        title="Traceability",
+        priority=9,
+        trigger="traceability",
+        summary_template="Summarize traceability using counts and one next action.",
+        empty_template="No active traceability issue needs attention.",
+        metric_key="traceability_count",
+        detail_prompt="Expand traceability only when the reviewer needs proof.",
+        quiet_copy="Keep traceability as a collapsed report section.",
+        action_label="Review traceability",
+    ),
+    ReportSectionDefinition(
+        section_id="section_009_quiet",
+        title="Visual pressure control",
+        priority=10,
+        trigger="quiet",
+        summary_template="Summarize visual pressure control using counts and one next action.",
+        empty_template="No active visual pressure control issue needs attention.",
+        metric_key="quiet_count",
+        detail_prompt="Expand visual pressure control only when the reviewer needs proof.",
+        quiet_copy="Keep visual pressure control as a collapsed report section.",
+        action_label="Review visual pressure control",
+    ),
+    ReportSectionDefinition(
+        section_id="section_010_risk",
+        title="Risk queue",
+        priority=11,
+        trigger="risk",
+        summary_template="Summarize risk queue using counts and one next action.",
+        empty_template="No active risk queue issue needs attention.",
+        metric_key="risk_count",
+        detail_prompt="Expand risk queue only when the reviewer needs proof.",
+        quiet_copy="Keep risk queue as a collapsed report section.",
+        action_label="Review risk queue",
+    ),
+    ReportSectionDefinition(
+        section_id="section_011_ai",
+        title="AI inference debt",
+        priority=12,
+        trigger="ai",
+        summary_template="Summarize ai inference debt using counts and one next action.",
+        empty_template="No active ai inference debt issue needs attention.",
+        metric_key="ai_count",
+        detail_prompt="Expand ai inference debt only when the reviewer needs proof.",
+        quiet_copy="Keep ai inference debt as a collapsed report section.",
+        action_label="Review ai inference debt",
+    ),
+    ReportSectionDefinition(
+        section_id="section_012_evidence",
+        title="Evidence coverage",
+        priority=1,
+        trigger="evidence",
+        summary_template="Summarize evidence coverage using counts and one next action.",
+        empty_template="No active evidence coverage issue needs attention.",
+        metric_key="evidence_count",
+        detail_prompt="Expand evidence coverage only when the reviewer needs proof.",
+        quiet_copy="Keep evidence coverage as a collapsed report section.",
+        action_label="Review evidence coverage",
+    ),
+    ReportSectionDefinition(
+        section_id="section_013_loops",
+        title="Open-loop pressure",
+        priority=2,
+        trigger="loops",
+        summary_template="Summarize open-loop pressure using counts and one next action.",
+        empty_template="No active open-loop pressure issue needs attention.",
+        metric_key="loops_count",
+        detail_prompt="Expand open-loop pressure only when the reviewer needs proof.",
+        quiet_copy="Keep open-loop pressure as a collapsed report section.",
+        action_label="Review open-loop pressure",
+    ),
+    ReportSectionDefinition(
+        section_id="section_014_history",
+        title="Review history",
+        priority=3,
+        trigger="history",
+        summary_template="Summarize review history using counts and one next action.",
+        empty_template="No active review history issue needs attention.",
+        metric_key="history_count",
+        detail_prompt="Expand review history only when the reviewer needs proof.",
+        quiet_copy="Keep review history as a collapsed report section.",
+        action_label="Review review history",
+    ),
+    ReportSectionDefinition(
+        section_id="section_015_topics",
+        title="Topic reuse",
+        priority=4,
+        trigger="topics",
+        summary_template="Summarize topic reuse using counts and one next action.",
+        empty_template="No active topic reuse issue needs attention.",
+        metric_key="topics_count",
+        detail_prompt="Expand topic reuse only when the reviewer needs proof.",
+        quiet_copy="Keep topic reuse as a collapsed report section.",
+        action_label="Review topic reuse",
+    ),
+    ReportSectionDefinition(
+        section_id="section_016_recall",
+        title="Future recall impact",
+        priority=5,
+        trigger="recall",
+        summary_template="Summarize future recall impact using counts and one next action.",
+        empty_template="No active future recall impact issue needs attention.",
+        metric_key="recall_count",
+        detail_prompt="Expand future recall impact only when the reviewer needs proof.",
+        quiet_copy="Keep future recall impact as a collapsed report section.",
+        action_label="Review future recall impact",
+    ),
+    ReportSectionDefinition(
+        section_id="section_017_decisions",
+        title="Decision readiness",
+        priority=6,
+        trigger="decisions",
+        summary_template="Summarize decision readiness using counts and one next action.",
+        empty_template="No active decision readiness issue needs attention.",
+        metric_key="decisions_count",
+        detail_prompt="Expand decision readiness only when the reviewer needs proof.",
+        quiet_copy="Keep decision readiness as a collapsed report section.",
+        action_label="Review decision readiness",
+    ),
+    ReportSectionDefinition(
+        section_id="section_018_traceability",
+        title="Traceability",
+        priority=7,
+        trigger="traceability",
+        summary_template="Summarize traceability using counts and one next action.",
+        empty_template="No active traceability issue needs attention.",
+        metric_key="traceability_count",
+        detail_prompt="Expand traceability only when the reviewer needs proof.",
+        quiet_copy="Keep traceability as a collapsed report section.",
+        action_label="Review traceability",
+    ),
+    ReportSectionDefinition(
+        section_id="section_019_quiet",
+        title="Visual pressure control",
+        priority=8,
+        trigger="quiet",
+        summary_template="Summarize visual pressure control using counts and one next action.",
+        empty_template="No active visual pressure control issue needs attention.",
+        metric_key="quiet_count",
+        detail_prompt="Expand visual pressure control only when the reviewer needs proof.",
+        quiet_copy="Keep visual pressure control as a collapsed report section.",
+        action_label="Review visual pressure control",
+    ),
+    ReportSectionDefinition(
+        section_id="section_020_risk",
+        title="Risk queue",
+        priority=9,
+        trigger="risk",
+        summary_template="Summarize risk queue using counts and one next action.",
+        empty_template="No active risk queue issue needs attention.",
+        metric_key="risk_count",
+        detail_prompt="Expand risk queue only when the reviewer needs proof.",
+        quiet_copy="Keep risk queue as a collapsed report section.",
+        action_label="Review risk queue",
+    ),
+    ReportSectionDefinition(
+        section_id="section_021_ai",
+        title="AI inference debt",
+        priority=10,
+        trigger="ai",
+        summary_template="Summarize ai inference debt using counts and one next action.",
+        empty_template="No active ai inference debt issue needs attention.",
+        metric_key="ai_count",
+        detail_prompt="Expand ai inference debt only when the reviewer needs proof.",
+        quiet_copy="Keep ai inference debt as a collapsed report section.",
+        action_label="Review ai inference debt",
+    ),
+    ReportSectionDefinition(
+        section_id="section_022_evidence",
+        title="Evidence coverage",
+        priority=11,
+        trigger="evidence",
+        summary_template="Summarize evidence coverage using counts and one next action.",
+        empty_template="No active evidence coverage issue needs attention.",
+        metric_key="evidence_count",
+        detail_prompt="Expand evidence coverage only when the reviewer needs proof.",
+        quiet_copy="Keep evidence coverage as a collapsed report section.",
+        action_label="Review evidence coverage",
+    ),
+    ReportSectionDefinition(
+        section_id="section_023_loops",
+        title="Open-loop pressure",
+        priority=12,
+        trigger="loops",
+        summary_template="Summarize open-loop pressure using counts and one next action.",
+        empty_template="No active open-loop pressure issue needs attention.",
+        metric_key="loops_count",
+        detail_prompt="Expand open-loop pressure only when the reviewer needs proof.",
+        quiet_copy="Keep open-loop pressure as a collapsed report section.",
+        action_label="Review open-loop pressure",
+    ),
+    ReportSectionDefinition(
+        section_id="section_024_history",
+        title="Review history",
+        priority=1,
+        trigger="history",
+        summary_template="Summarize review history using counts and one next action.",
+        empty_template="No active review history issue needs attention.",
+        metric_key="history_count",
+        detail_prompt="Expand review history only when the reviewer needs proof.",
+        quiet_copy="Keep review history as a collapsed report section.",
+        action_label="Review review history",
+    ),
+    ReportSectionDefinition(
+        section_id="section_025_topics",
+        title="Topic reuse",
+        priority=2,
+        trigger="topics",
+        summary_template="Summarize topic reuse using counts and one next action.",
+        empty_template="No active topic reuse issue needs attention.",
+        metric_key="topics_count",
+        detail_prompt="Expand topic reuse only when the reviewer needs proof.",
+        quiet_copy="Keep topic reuse as a collapsed report section.",
+        action_label="Review topic reuse",
+    ),
+    ReportSectionDefinition(
+        section_id="section_026_recall",
+        title="Future recall impact",
+        priority=3,
+        trigger="recall",
+        summary_template="Summarize future recall impact using counts and one next action.",
+        empty_template="No active future recall impact issue needs attention.",
+        metric_key="recall_count",
+        detail_prompt="Expand future recall impact only when the reviewer needs proof.",
+        quiet_copy="Keep future recall impact as a collapsed report section.",
+        action_label="Review future recall impact",
+    ),
+    ReportSectionDefinition(
+        section_id="section_027_decisions",
+        title="Decision readiness",
+        priority=4,
+        trigger="decisions",
+        summary_template="Summarize decision readiness using counts and one next action.",
+        empty_template="No active decision readiness issue needs attention.",
+        metric_key="decisions_count",
+        detail_prompt="Expand decision readiness only when the reviewer needs proof.",
+        quiet_copy="Keep decision readiness as a collapsed report section.",
+        action_label="Review decision readiness",
+    ),
+    ReportSectionDefinition(
+        section_id="section_028_traceability",
+        title="Traceability",
+        priority=5,
+        trigger="traceability",
+        summary_template="Summarize traceability using counts and one next action.",
+        empty_template="No active traceability issue needs attention.",
+        metric_key="traceability_count",
+        detail_prompt="Expand traceability only when the reviewer needs proof.",
+        quiet_copy="Keep traceability as a collapsed report section.",
+        action_label="Review traceability",
+    ),
+    ReportSectionDefinition(
+        section_id="section_029_quiet",
+        title="Visual pressure control",
+        priority=6,
+        trigger="quiet",
+        summary_template="Summarize visual pressure control using counts and one next action.",
+        empty_template="No active visual pressure control issue needs attention.",
+        metric_key="quiet_count",
+        detail_prompt="Expand visual pressure control only when the reviewer needs proof.",
+        quiet_copy="Keep visual pressure control as a collapsed report section.",
+        action_label="Review visual pressure control",
+    ),
+    ReportSectionDefinition(
+        section_id="section_030_risk",
+        title="Risk queue",
+        priority=7,
+        trigger="risk",
+        summary_template="Summarize risk queue using counts and one next action.",
+        empty_template="No active risk queue issue needs attention.",
+        metric_key="risk_count",
+        detail_prompt="Expand risk queue only when the reviewer needs proof.",
+        quiet_copy="Keep risk queue as a collapsed report section.",
+        action_label="Review risk queue",
+    ),
+    ReportSectionDefinition(
+        section_id="section_031_ai",
+        title="AI inference debt",
+        priority=8,
+        trigger="ai",
+        summary_template="Summarize ai inference debt using counts and one next action.",
+        empty_template="No active ai inference debt issue needs attention.",
+        metric_key="ai_count",
+        detail_prompt="Expand ai inference debt only when the reviewer needs proof.",
+        quiet_copy="Keep ai inference debt as a collapsed report section.",
+        action_label="Review ai inference debt",
+    ),
+    ReportSectionDefinition(
+        section_id="section_032_evidence",
+        title="Evidence coverage",
+        priority=9,
+        trigger="evidence",
+        summary_template="Summarize evidence coverage using counts and one next action.",
+        empty_template="No active evidence coverage issue needs attention.",
+        metric_key="evidence_count",
+        detail_prompt="Expand evidence coverage only when the reviewer needs proof.",
+        quiet_copy="Keep evidence coverage as a collapsed report section.",
+        action_label="Review evidence coverage",
+    ),
+    ReportSectionDefinition(
+        section_id="section_033_loops",
+        title="Open-loop pressure",
+        priority=10,
+        trigger="loops",
+        summary_template="Summarize open-loop pressure using counts and one next action.",
+        empty_template="No active open-loop pressure issue needs attention.",
+        metric_key="loops_count",
+        detail_prompt="Expand open-loop pressure only when the reviewer needs proof.",
+        quiet_copy="Keep open-loop pressure as a collapsed report section.",
+        action_label="Review open-loop pressure",
+    ),
+    ReportSectionDefinition(
+        section_id="section_034_history",
+        title="Review history",
+        priority=11,
+        trigger="history",
+        summary_template="Summarize review history using counts and one next action.",
+        empty_template="No active review history issue needs attention.",
+        metric_key="history_count",
+        detail_prompt="Expand review history only when the reviewer needs proof.",
+        quiet_copy="Keep review history as a collapsed report section.",
+        action_label="Review review history",
+    ),
+    ReportSectionDefinition(
+        section_id="section_035_topics",
+        title="Topic reuse",
+        priority=12,
+        trigger="topics",
+        summary_template="Summarize topic reuse using counts and one next action.",
+        empty_template="No active topic reuse issue needs attention.",
+        metric_key="topics_count",
+        detail_prompt="Expand topic reuse only when the reviewer needs proof.",
+        quiet_copy="Keep topic reuse as a collapsed report section.",
+        action_label="Review topic reuse",
+    ),
+    ReportSectionDefinition(
+        section_id="section_036_recall",
+        title="Future recall impact",
+        priority=1,
+        trigger="recall",
+        summary_template="Summarize future recall impact using counts and one next action.",
+        empty_template="No active future recall impact issue needs attention.",
+        metric_key="recall_count",
+        detail_prompt="Expand future recall impact only when the reviewer needs proof.",
+        quiet_copy="Keep future recall impact as a collapsed report section.",
+        action_label="Review future recall impact",
+    ),
+    ReportSectionDefinition(
+        section_id="section_037_decisions",
+        title="Decision readiness",
+        priority=2,
+        trigger="decisions",
+        summary_template="Summarize decision readiness using counts and one next action.",
+        empty_template="No active decision readiness issue needs attention.",
+        metric_key="decisions_count",
+        detail_prompt="Expand decision readiness only when the reviewer needs proof.",
+        quiet_copy="Keep decision readiness as a collapsed report section.",
+        action_label="Review decision readiness",
+    ),
+    ReportSectionDefinition(
+        section_id="section_038_traceability",
+        title="Traceability",
+        priority=3,
+        trigger="traceability",
+        summary_template="Summarize traceability using counts and one next action.",
+        empty_template="No active traceability issue needs attention.",
+        metric_key="traceability_count",
+        detail_prompt="Expand traceability only when the reviewer needs proof.",
+        quiet_copy="Keep traceability as a collapsed report section.",
+        action_label="Review traceability",
+    ),
+    ReportSectionDefinition(
+        section_id="section_039_quiet",
+        title="Visual pressure control",
+        priority=4,
+        trigger="quiet",
+        summary_template="Summarize visual pressure control using counts and one next action.",
+        empty_template="No active visual pressure control issue needs attention.",
+        metric_key="quiet_count",
+        detail_prompt="Expand visual pressure control only when the reviewer needs proof.",
+        quiet_copy="Keep visual pressure control as a collapsed report section.",
+        action_label="Review visual pressure control",
+    ),
+    ReportSectionDefinition(
+        section_id="section_040_risk",
+        title="Risk queue",
+        priority=5,
+        trigger="risk",
+        summary_template="Summarize risk queue using counts and one next action.",
+        empty_template="No active risk queue issue needs attention.",
+        metric_key="risk_count",
+        detail_prompt="Expand risk queue only when the reviewer needs proof.",
+        quiet_copy="Keep risk queue as a collapsed report section.",
+        action_label="Review risk queue",
+    ),
+    ReportSectionDefinition(
+        section_id="section_041_ai",
+        title="AI inference debt",
+        priority=6,
+        trigger="ai",
+        summary_template="Summarize ai inference debt using counts and one next action.",
+        empty_template="No active ai inference debt issue needs attention.",
+        metric_key="ai_count",
+        detail_prompt="Expand ai inference debt only when the reviewer needs proof.",
+        quiet_copy="Keep ai inference debt as a collapsed report section.",
+        action_label="Review ai inference debt",
+    ),
+    ReportSectionDefinition(
+        section_id="section_042_evidence",
+        title="Evidence coverage",
+        priority=7,
+        trigger="evidence",
+        summary_template="Summarize evidence coverage using counts and one next action.",
+        empty_template="No active evidence coverage issue needs attention.",
+        metric_key="evidence_count",
+        detail_prompt="Expand evidence coverage only when the reviewer needs proof.",
+        quiet_copy="Keep evidence coverage as a collapsed report section.",
+        action_label="Review evidence coverage",
+    ),
+    ReportSectionDefinition(
+        section_id="section_043_loops",
+        title="Open-loop pressure",
+        priority=8,
+        trigger="loops",
+        summary_template="Summarize open-loop pressure using counts and one next action.",
+        empty_template="No active open-loop pressure issue needs attention.",
+        metric_key="loops_count",
+        detail_prompt="Expand open-loop pressure only when the reviewer needs proof.",
+        quiet_copy="Keep open-loop pressure as a collapsed report section.",
+        action_label="Review open-loop pressure",
+    ),
+    ReportSectionDefinition(
+        section_id="section_044_history",
+        title="Review history",
+        priority=9,
+        trigger="history",
+        summary_template="Summarize review history using counts and one next action.",
+        empty_template="No active review history issue needs attention.",
+        metric_key="history_count",
+        detail_prompt="Expand review history only when the reviewer needs proof.",
+        quiet_copy="Keep review history as a collapsed report section.",
+        action_label="Review review history",
+    ),
+    ReportSectionDefinition(
+        section_id="section_045_topics",
+        title="Topic reuse",
+        priority=10,
+        trigger="topics",
+        summary_template="Summarize topic reuse using counts and one next action.",
+        empty_template="No active topic reuse issue needs attention.",
+        metric_key="topics_count",
+        detail_prompt="Expand topic reuse only when the reviewer needs proof.",
+        quiet_copy="Keep topic reuse as a collapsed report section.",
+        action_label="Review topic reuse",
+    ),
+    ReportSectionDefinition(
+        section_id="section_046_recall",
+        title="Future recall impact",
+        priority=11,
+        trigger="recall",
+        summary_template="Summarize future recall impact using counts and one next action.",
+        empty_template="No active future recall impact issue needs attention.",
+        metric_key="recall_count",
+        detail_prompt="Expand future recall impact only when the reviewer needs proof.",
+        quiet_copy="Keep future recall impact as a collapsed report section.",
+        action_label="Review future recall impact",
+    ),
+    ReportSectionDefinition(
+        section_id="section_047_decisions",
+        title="Decision readiness",
+        priority=12,
+        trigger="decisions",
+        summary_template="Summarize decision readiness using counts and one next action.",
+        empty_template="No active decision readiness issue needs attention.",
+        metric_key="decisions_count",
+        detail_prompt="Expand decision readiness only when the reviewer needs proof.",
+        quiet_copy="Keep decision readiness as a collapsed report section.",
+        action_label="Review decision readiness",
+    ),
+    ReportSectionDefinition(
+        section_id="section_048_traceability",
+        title="Traceability",
+        priority=1,
+        trigger="traceability",
+        summary_template="Summarize traceability using counts and one next action.",
+        empty_template="No active traceability issue needs attention.",
+        metric_key="traceability_count",
+        detail_prompt="Expand traceability only when the reviewer needs proof.",
+        quiet_copy="Keep traceability as a collapsed report section.",
+        action_label="Review traceability",
+    ),
+    ReportSectionDefinition(
+        section_id="section_049_quiet",
+        title="Visual pressure control",
+        priority=2,
+        trigger="quiet",
+        summary_template="Summarize visual pressure control using counts and one next action.",
+        empty_template="No active visual pressure control issue needs attention.",
+        metric_key="quiet_count",
+        detail_prompt="Expand visual pressure control only when the reviewer needs proof.",
+        quiet_copy="Keep visual pressure control as a collapsed report section.",
+        action_label="Review visual pressure control",
+    ),
+    ReportSectionDefinition(
+        section_id="section_050_risk",
+        title="Risk queue",
+        priority=3,
+        trigger="risk",
+        summary_template="Summarize risk queue using counts and one next action.",
+        empty_template="No active risk queue issue needs attention.",
+        metric_key="risk_count",
+        detail_prompt="Expand risk queue only when the reviewer needs proof.",
+        quiet_copy="Keep risk queue as a collapsed report section.",
+        action_label="Review risk queue",
+    ),
+    ReportSectionDefinition(
+        section_id="section_051_ai",
+        title="AI inference debt",
+        priority=4,
+        trigger="ai",
+        summary_template="Summarize ai inference debt using counts and one next action.",
+        empty_template="No active ai inference debt issue needs attention.",
+        metric_key="ai_count",
+        detail_prompt="Expand ai inference debt only when the reviewer needs proof.",
+        quiet_copy="Keep ai inference debt as a collapsed report section.",
+        action_label="Review ai inference debt",
+    ),
+    ReportSectionDefinition(
+        section_id="section_052_evidence",
+        title="Evidence coverage",
+        priority=5,
+        trigger="evidence",
+        summary_template="Summarize evidence coverage using counts and one next action.",
+        empty_template="No active evidence coverage issue needs attention.",
+        metric_key="evidence_count",
+        detail_prompt="Expand evidence coverage only when the reviewer needs proof.",
+        quiet_copy="Keep evidence coverage as a collapsed report section.",
+        action_label="Review evidence coverage",
+    ),
+    ReportSectionDefinition(
+        section_id="section_053_loops",
+        title="Open-loop pressure",
+        priority=6,
+        trigger="loops",
+        summary_template="Summarize open-loop pressure using counts and one next action.",
+        empty_template="No active open-loop pressure issue needs attention.",
+        metric_key="loops_count",
+        detail_prompt="Expand open-loop pressure only when the reviewer needs proof.",
+        quiet_copy="Keep open-loop pressure as a collapsed report section.",
+        action_label="Review open-loop pressure",
+    ),
+    ReportSectionDefinition(
+        section_id="section_054_history",
+        title="Review history",
+        priority=7,
+        trigger="history",
+        summary_template="Summarize review history using counts and one next action.",
+        empty_template="No active review history issue needs attention.",
+        metric_key="history_count",
+        detail_prompt="Expand review history only when the reviewer needs proof.",
+        quiet_copy="Keep review history as a collapsed report section.",
+        action_label="Review review history",
+    ),
+    ReportSectionDefinition(
+        section_id="section_055_topics",
+        title="Topic reuse",
+        priority=8,
+        trigger="topics",
+        summary_template="Summarize topic reuse using counts and one next action.",
+        empty_template="No active topic reuse issue needs attention.",
+        metric_key="topics_count",
+        detail_prompt="Expand topic reuse only when the reviewer needs proof.",
+        quiet_copy="Keep topic reuse as a collapsed report section.",
+        action_label="Review topic reuse",
+    ),
+    ReportSectionDefinition(
+        section_id="section_056_recall",
+        title="Future recall impact",
+        priority=9,
+        trigger="recall",
+        summary_template="Summarize future recall impact using counts and one next action.",
+        empty_template="No active future recall impact issue needs attention.",
+        metric_key="recall_count",
+        detail_prompt="Expand future recall impact only when the reviewer needs proof.",
+        quiet_copy="Keep future recall impact as a collapsed report section.",
+        action_label="Review future recall impact",
+    ),
+    ReportSectionDefinition(
+        section_id="section_057_decisions",
+        title="Decision readiness",
+        priority=10,
+        trigger="decisions",
+        summary_template="Summarize decision readiness using counts and one next action.",
+        empty_template="No active decision readiness issue needs attention.",
+        metric_key="decisions_count",
+        detail_prompt="Expand decision readiness only when the reviewer needs proof.",
+        quiet_copy="Keep decision readiness as a collapsed report section.",
+        action_label="Review decision readiness",
+    ),
+    ReportSectionDefinition(
+        section_id="section_058_traceability",
+        title="Traceability",
+        priority=11,
+        trigger="traceability",
+        summary_template="Summarize traceability using counts and one next action.",
+        empty_template="No active traceability issue needs attention.",
+        metric_key="traceability_count",
+        detail_prompt="Expand traceability only when the reviewer needs proof.",
+        quiet_copy="Keep traceability as a collapsed report section.",
+        action_label="Review traceability",
+    ),
+    ReportSectionDefinition(
+        section_id="section_059_quiet",
+        title="Visual pressure control",
+        priority=12,
+        trigger="quiet",
+        summary_template="Summarize visual pressure control using counts and one next action.",
+        empty_template="No active visual pressure control issue needs attention.",
+        metric_key="quiet_count",
+        detail_prompt="Expand visual pressure control only when the reviewer needs proof.",
+        quiet_copy="Keep visual pressure control as a collapsed report section.",
+        action_label="Review visual pressure control",
+    ),
+    ReportSectionDefinition(
+        section_id="section_060_risk",
+        title="Risk queue",
+        priority=1,
+        trigger="risk",
+        summary_template="Summarize risk queue using counts and one next action.",
+        empty_template="No active risk queue issue needs attention.",
+        metric_key="risk_count",
+        detail_prompt="Expand risk queue only when the reviewer needs proof.",
+        quiet_copy="Keep risk queue as a collapsed report section.",
+        action_label="Review risk queue",
+    ),
+    ReportSectionDefinition(
+        section_id="section_061_ai",
+        title="AI inference debt",
+        priority=2,
+        trigger="ai",
+        summary_template="Summarize ai inference debt using counts and one next action.",
+        empty_template="No active ai inference debt issue needs attention.",
+        metric_key="ai_count",
+        detail_prompt="Expand ai inference debt only when the reviewer needs proof.",
+        quiet_copy="Keep ai inference debt as a collapsed report section.",
+        action_label="Review ai inference debt",
+    ),
+    ReportSectionDefinition(
+        section_id="section_062_evidence",
+        title="Evidence coverage",
+        priority=3,
+        trigger="evidence",
+        summary_template="Summarize evidence coverage using counts and one next action.",
+        empty_template="No active evidence coverage issue needs attention.",
+        metric_key="evidence_count",
+        detail_prompt="Expand evidence coverage only when the reviewer needs proof.",
+        quiet_copy="Keep evidence coverage as a collapsed report section.",
+        action_label="Review evidence coverage",
+    ),
+    ReportSectionDefinition(
+        section_id="section_063_loops",
+        title="Open-loop pressure",
+        priority=4,
+        trigger="loops",
+        summary_template="Summarize open-loop pressure using counts and one next action.",
+        empty_template="No active open-loop pressure issue needs attention.",
+        metric_key="loops_count",
+        detail_prompt="Expand open-loop pressure only when the reviewer needs proof.",
+        quiet_copy="Keep open-loop pressure as a collapsed report section.",
+        action_label="Review open-loop pressure",
+    ),
+    ReportSectionDefinition(
+        section_id="section_064_history",
+        title="Review history",
+        priority=5,
+        trigger="history",
+        summary_template="Summarize review history using counts and one next action.",
+        empty_template="No active review history issue needs attention.",
+        metric_key="history_count",
+        detail_prompt="Expand review history only when the reviewer needs proof.",
+        quiet_copy="Keep review history as a collapsed report section.",
+        action_label="Review review history",
+    ),
+    ReportSectionDefinition(
+        section_id="section_065_topics",
+        title="Topic reuse",
+        priority=6,
+        trigger="topics",
+        summary_template="Summarize topic reuse using counts and one next action.",
+        empty_template="No active topic reuse issue needs attention.",
+        metric_key="topics_count",
+        detail_prompt="Expand topic reuse only when the reviewer needs proof.",
+        quiet_copy="Keep topic reuse as a collapsed report section.",
+        action_label="Review topic reuse",
+    ),
+    ReportSectionDefinition(
+        section_id="section_066_recall",
+        title="Future recall impact",
+        priority=7,
+        trigger="recall",
+        summary_template="Summarize future recall impact using counts and one next action.",
+        empty_template="No active future recall impact issue needs attention.",
+        metric_key="recall_count",
+        detail_prompt="Expand future recall impact only when the reviewer needs proof.",
+        quiet_copy="Keep future recall impact as a collapsed report section.",
+        action_label="Review future recall impact",
+    ),
+    ReportSectionDefinition(
+        section_id="section_067_decisions",
+        title="Decision readiness",
+        priority=8,
+        trigger="decisions",
+        summary_template="Summarize decision readiness using counts and one next action.",
+        empty_template="No active decision readiness issue needs attention.",
+        metric_key="decisions_count",
+        detail_prompt="Expand decision readiness only when the reviewer needs proof.",
+        quiet_copy="Keep decision readiness as a collapsed report section.",
+        action_label="Review decision readiness",
+    ),
+    ReportSectionDefinition(
+        section_id="section_068_traceability",
+        title="Traceability",
+        priority=9,
+        trigger="traceability",
+        summary_template="Summarize traceability using counts and one next action.",
+        empty_template="No active traceability issue needs attention.",
+        metric_key="traceability_count",
+        detail_prompt="Expand traceability only when the reviewer needs proof.",
+        quiet_copy="Keep traceability as a collapsed report section.",
+        action_label="Review traceability",
+    ),
+    ReportSectionDefinition(
+        section_id="section_069_quiet",
+        title="Visual pressure control",
+        priority=10,
+        trigger="quiet",
+        summary_template="Summarize visual pressure control using counts and one next action.",
+        empty_template="No active visual pressure control issue needs attention.",
+        metric_key="quiet_count",
+        detail_prompt="Expand visual pressure control only when the reviewer needs proof.",
+        quiet_copy="Keep visual pressure control as a collapsed report section.",
+        action_label="Review visual pressure control",
+    ),
+    ReportSectionDefinition(
+        section_id="section_070_risk",
+        title="Risk queue",
+        priority=11,
+        trigger="risk",
+        summary_template="Summarize risk queue using counts and one next action.",
+        empty_template="No active risk queue issue needs attention.",
+        metric_key="risk_count",
+        detail_prompt="Expand risk queue only when the reviewer needs proof.",
+        quiet_copy="Keep risk queue as a collapsed report section.",
+        action_label="Review risk queue",
+    ),
+    ReportSectionDefinition(
+        section_id="section_071_ai",
+        title="AI inference debt",
+        priority=12,
+        trigger="ai",
+        summary_template="Summarize ai inference debt using counts and one next action.",
+        empty_template="No active ai inference debt issue needs attention.",
+        metric_key="ai_count",
+        detail_prompt="Expand ai inference debt only when the reviewer needs proof.",
+        quiet_copy="Keep ai inference debt as a collapsed report section.",
+        action_label="Review ai inference debt",
+    ),
+    ReportSectionDefinition(
+        section_id="section_072_evidence",
+        title="Evidence coverage",
+        priority=1,
+        trigger="evidence",
+        summary_template="Summarize evidence coverage using counts and one next action.",
+        empty_template="No active evidence coverage issue needs attention.",
+        metric_key="evidence_count",
+        detail_prompt="Expand evidence coverage only when the reviewer needs proof.",
+        quiet_copy="Keep evidence coverage as a collapsed report section.",
+        action_label="Review evidence coverage",
+    ),
+    ReportSectionDefinition(
+        section_id="section_073_loops",
+        title="Open-loop pressure",
+        priority=2,
+        trigger="loops",
+        summary_template="Summarize open-loop pressure using counts and one next action.",
+        empty_template="No active open-loop pressure issue needs attention.",
+        metric_key="loops_count",
+        detail_prompt="Expand open-loop pressure only when the reviewer needs proof.",
+        quiet_copy="Keep open-loop pressure as a collapsed report section.",
+        action_label="Review open-loop pressure",
+    ),
+    ReportSectionDefinition(
+        section_id="section_074_history",
+        title="Review history",
+        priority=3,
+        trigger="history",
+        summary_template="Summarize review history using counts and one next action.",
+        empty_template="No active review history issue needs attention.",
+        metric_key="history_count",
+        detail_prompt="Expand review history only when the reviewer needs proof.",
+        quiet_copy="Keep review history as a collapsed report section.",
+        action_label="Review review history",
+    ),
+    ReportSectionDefinition(
+        section_id="section_075_topics",
+        title="Topic reuse",
+        priority=4,
+        trigger="topics",
+        summary_template="Summarize topic reuse using counts and one next action.",
+        empty_template="No active topic reuse issue needs attention.",
+        metric_key="topics_count",
+        detail_prompt="Expand topic reuse only when the reviewer needs proof.",
+        quiet_copy="Keep topic reuse as a collapsed report section.",
+        action_label="Review topic reuse",
+    ),
+    ReportSectionDefinition(
+        section_id="section_076_recall",
+        title="Future recall impact",
+        priority=5,
+        trigger="recall",
+        summary_template="Summarize future recall impact using counts and one next action.",
+        empty_template="No active future recall impact issue needs attention.",
+        metric_key="recall_count",
+        detail_prompt="Expand future recall impact only when the reviewer needs proof.",
+        quiet_copy="Keep future recall impact as a collapsed report section.",
+        action_label="Review future recall impact",
+    ),
+    ReportSectionDefinition(
+        section_id="section_077_decisions",
+        title="Decision readiness",
+        priority=6,
+        trigger="decisions",
+        summary_template="Summarize decision readiness using counts and one next action.",
+        empty_template="No active decision readiness issue needs attention.",
+        metric_key="decisions_count",
+        detail_prompt="Expand decision readiness only when the reviewer needs proof.",
+        quiet_copy="Keep decision readiness as a collapsed report section.",
+        action_label="Review decision readiness",
+    ),
+    ReportSectionDefinition(
+        section_id="section_078_traceability",
+        title="Traceability",
+        priority=7,
+        trigger="traceability",
+        summary_template="Summarize traceability using counts and one next action.",
+        empty_template="No active traceability issue needs attention.",
+        metric_key="traceability_count",
+        detail_prompt="Expand traceability only when the reviewer needs proof.",
+        quiet_copy="Keep traceability as a collapsed report section.",
+        action_label="Review traceability",
+    ),
+    ReportSectionDefinition(
+        section_id="section_079_quiet",
+        title="Visual pressure control",
+        priority=8,
+        trigger="quiet",
+        summary_template="Summarize visual pressure control using counts and one next action.",
+        empty_template="No active visual pressure control issue needs attention.",
+        metric_key="quiet_count",
+        detail_prompt="Expand visual pressure control only when the reviewer needs proof.",
+        quiet_copy="Keep visual pressure control as a collapsed report section.",
+        action_label="Review visual pressure control",
+    ),
+)
+
+SESSION_MODE_DEFINITIONS: tuple[SessionModeDefinition, ...] = (
+    SessionModeDefinition(
+        mode_id="high-risk",
+        label="High-risk first",
+        intent="Reduce trust risk before broad cleanup.",
+        ordering=("critical", "high"),
+        include_risks=("critical", "high"),
+        include_statuses=("unreviewed", "deferred"),
+        empty_copy="No item currently needs this review mode.",
+        next_step_copy="Open the first matching item and decide from compressed evidence.",
+        quiet_rule="Show counts first and hide secondary details behind disclosure.",
+        completion_copy="This mode is clear enough for now.",
+    ),
+    SessionModeDefinition(
+        mode_id="quick-clear",
+        label="Quick clear",
+        intent="Clear low-pressure items quickly.",
+        ordering=("medium", "low"),
+        include_risks=("medium", "low"),
+        include_statuses=("unreviewed", "confirmed", "rewritten"),
+        empty_copy="No item currently needs this review mode.",
+        next_step_copy="Open the first matching item and decide from compressed evidence.",
+        quiet_rule="Show counts first and hide secondary details behind disclosure.",
+        completion_copy="This mode is clear enough for now.",
+    ),
+    SessionModeDefinition(
+        mode_id="open-loops",
+        label="Open loops",
+        intent="Turn unresolved work into next actions.",
+        ordering=("critical", "high", "medium"),
+        include_risks=("critical", "high", "medium"),
+        include_statuses=("unreviewed", "deferred"),
+        empty_copy="No item currently needs this review mode.",
+        next_step_copy="Open the first matching item and decide from compressed evidence.",
+        quiet_rule="Show counts first and hide secondary details behind disclosure.",
+        completion_copy="This mode is clear enough for now.",
+    ),
+    SessionModeDefinition(
+        mode_id="all",
+        label="All items",
+        intent="Inspect every trust item in one queue.",
+        ordering=("critical", "high", "medium", "low"),
+        include_risks=("critical", "high", "medium", "low"),
+        include_statuses=("unreviewed", "deferred", "confirmed", "rewritten", "rejected"),
+        empty_copy="No item currently needs this review mode.",
+        next_step_copy="Open the first matching item and decide from compressed evidence.",
+        quiet_rule="Show counts first and hide secondary details behind disclosure.",
+        completion_copy="This mode is clear enough for now.",
+    ),
+    SessionModeDefinition(
+        mode_id="deferred",
+        label="Deferred decisions",
+        intent="Resume postponed decisions with context.",
+        ordering=("critical", "high", "medium"),
+        include_risks=("critical", "high", "medium"),
+        include_statuses=("deferred",),
+        empty_copy="No item currently needs this review mode.",
+        next_step_copy="Open the first matching item and decide from compressed evidence.",
+        quiet_rule="Show counts first and hide secondary details behind disclosure.",
+        completion_copy="This mode is clear enough for now.",
+    ),
+    SessionModeDefinition(
+        mode_id="ai-only",
+        label="AI inferred only",
+        intent="Separate model guesses from user-stated reasons.",
+        ordering=("critical", "high", "medium", "low"),
+        include_risks=("critical", "high", "medium", "low"),
+        include_statuses=("unreviewed", "deferred"),
+        empty_copy="No item currently needs this review mode.",
+        next_step_copy="Open the first matching item and decide from compressed evidence.",
+        quiet_rule="Show counts first and hide secondary details behind disclosure.",
+        completion_copy="This mode is clear enough for now.",
+    ),
+    SessionModeDefinition(
+        mode_id="trusted",
+        label="Trusted anchors",
+        intent="Review confirmed anchors without pressure.",
+        ordering=("low", "medium"),
+        include_risks=("low", "medium"),
+        include_statuses=("confirmed", "rewritten"),
+        empty_copy="No item currently needs this review mode.",
+        next_step_copy="Open the first matching item and decide from compressed evidence.",
+        quiet_rule="Show counts first and hide secondary details behind disclosure.",
+        completion_copy="This mode is clear enough for now.",
+    ),
+    SessionModeDefinition(
+        mode_id="cleanup",
+        label="Cleanup sweep",
+        intent="Find stale rejected or isolated trust records.",
+        ordering=("low", "medium"),
+        include_risks=("low", "medium"),
+        include_statuses=("rejected", "deferred"),
+        empty_copy="No item currently needs this review mode.",
+        next_step_copy="Open the first matching item and decide from compressed evidence.",
+        quiet_rule="Show counts first and hide secondary details behind disclosure.",
+        completion_copy="This mode is clear enough for now.",
+    ),
+)
+
+PRESSURE_GUARDRAIL_DEFINITIONS: tuple[PressureGuardrailDefinition, ...] = (
+    PressureGuardrailDefinition(
+        guardrail_id="guard_000_header",
+        surface="header",
+        trigger="header_pressure",
+        max_items=2,
+        collapsed_label="More header context",
+        expansion_label="Show header details",
+        reason="Limit header density so the reviewer sees the next decision first.",
+        fallback="Move lower-priority header copy into a disclosure block.",
+    ),
+    PressureGuardrailDefinition(
+        guardrail_id="guard_001_session",
+        surface="session",
+        trigger="session_pressure",
+        max_items=3,
+        collapsed_label="More session context",
+        expansion_label="Show session details",
+        reason="Limit session density so the reviewer sees the next decision first.",
+        fallback="Move lower-priority session copy into a disclosure block.",
+    ),
+    PressureGuardrailDefinition(
+        guardrail_id="guard_002_queue",
+        surface="queue",
+        trigger="queue_pressure",
+        max_items=4,
+        collapsed_label="More queue context",
+        expansion_label="Show queue details",
+        reason="Limit queue density so the reviewer sees the next decision first.",
+        fallback="Move lower-priority queue copy into a disclosure block.",
+    ),
+    PressureGuardrailDefinition(
+        guardrail_id="guard_003_detail",
+        surface="detail",
+        trigger="detail_pressure",
+        max_items=5,
+        collapsed_label="More detail context",
+        expansion_label="Show detail details",
+        reason="Limit detail density so the reviewer sees the next decision first.",
+        fallback="Move lower-priority detail copy into a disclosure block.",
+    ),
+    PressureGuardrailDefinition(
+        guardrail_id="guard_004_evidence",
+        surface="evidence",
+        trigger="evidence_pressure",
+        max_items=6,
+        collapsed_label="More evidence context",
+        expansion_label="Show evidence details",
+        reason="Limit evidence density so the reviewer sees the next decision first.",
+        fallback="Move lower-priority evidence copy into a disclosure block.",
+    ),
+    PressureGuardrailDefinition(
+        guardrail_id="guard_005_decision",
+        surface="decision",
+        trigger="decision_pressure",
+        max_items=2,
+        collapsed_label="More decision context",
+        expansion_label="Show decision details",
+        reason="Limit decision density so the reviewer sees the next decision first.",
+        fallback="Move lower-priority decision copy into a disclosure block.",
+    ),
+    PressureGuardrailDefinition(
+        guardrail_id="guard_006_diagnostics",
+        surface="diagnostics",
+        trigger="diagnostics_pressure",
+        max_items=3,
+        collapsed_label="More diagnostics context",
+        expansion_label="Show diagnostics details",
+        reason="Limit diagnostics density so the reviewer sees the next decision first.",
+        fallback="Move lower-priority diagnostics copy into a disclosure block.",
+    ),
+    PressureGuardrailDefinition(
+        guardrail_id="guard_007_report",
+        surface="report",
+        trigger="report_pressure",
+        max_items=4,
+        collapsed_label="More report context",
+        expansion_label="Show report details",
+        reason="Limit report density so the reviewer sees the next decision first.",
+        fallback="Move lower-priority report copy into a disclosure block.",
+    ),
+    PressureGuardrailDefinition(
+        guardrail_id="guard_008_header",
+        surface="header",
+        trigger="header_pressure",
+        max_items=5,
+        collapsed_label="More header context",
+        expansion_label="Show header details",
+        reason="Limit header density so the reviewer sees the next decision first.",
+        fallback="Move lower-priority header copy into a disclosure block.",
+    ),
+    PressureGuardrailDefinition(
+        guardrail_id="guard_009_session",
+        surface="session",
+        trigger="session_pressure",
+        max_items=6,
+        collapsed_label="More session context",
+        expansion_label="Show session details",
+        reason="Limit session density so the reviewer sees the next decision first.",
+        fallback="Move lower-priority session copy into a disclosure block.",
+    ),
+    PressureGuardrailDefinition(
+        guardrail_id="guard_010_queue",
+        surface="queue",
+        trigger="queue_pressure",
+        max_items=2,
+        collapsed_label="More queue context",
+        expansion_label="Show queue details",
+        reason="Limit queue density so the reviewer sees the next decision first.",
+        fallback="Move lower-priority queue copy into a disclosure block.",
+    ),
+    PressureGuardrailDefinition(
+        guardrail_id="guard_011_detail",
+        surface="detail",
+        trigger="detail_pressure",
+        max_items=3,
+        collapsed_label="More detail context",
+        expansion_label="Show detail details",
+        reason="Limit detail density so the reviewer sees the next decision first.",
+        fallback="Move lower-priority detail copy into a disclosure block.",
+    ),
+    PressureGuardrailDefinition(
+        guardrail_id="guard_012_evidence",
+        surface="evidence",
+        trigger="evidence_pressure",
+        max_items=4,
+        collapsed_label="More evidence context",
+        expansion_label="Show evidence details",
+        reason="Limit evidence density so the reviewer sees the next decision first.",
+        fallback="Move lower-priority evidence copy into a disclosure block.",
+    ),
+    PressureGuardrailDefinition(
+        guardrail_id="guard_013_decision",
+        surface="decision",
+        trigger="decision_pressure",
+        max_items=5,
+        collapsed_label="More decision context",
+        expansion_label="Show decision details",
+        reason="Limit decision density so the reviewer sees the next decision first.",
+        fallback="Move lower-priority decision copy into a disclosure block.",
+    ),
+    PressureGuardrailDefinition(
+        guardrail_id="guard_014_diagnostics",
+        surface="diagnostics",
+        trigger="diagnostics_pressure",
+        max_items=6,
+        collapsed_label="More diagnostics context",
+        expansion_label="Show diagnostics details",
+        reason="Limit diagnostics density so the reviewer sees the next decision first.",
+        fallback="Move lower-priority diagnostics copy into a disclosure block.",
+    ),
+    PressureGuardrailDefinition(
+        guardrail_id="guard_015_report",
+        surface="report",
+        trigger="report_pressure",
+        max_items=2,
+        collapsed_label="More report context",
+        expansion_label="Show report details",
+        reason="Limit report density so the reviewer sees the next decision first.",
+        fallback="Move lower-priority report copy into a disclosure block.",
+    ),
+    PressureGuardrailDefinition(
+        guardrail_id="guard_016_header",
+        surface="header",
+        trigger="header_pressure",
+        max_items=3,
+        collapsed_label="More header context",
+        expansion_label="Show header details",
+        reason="Limit header density so the reviewer sees the next decision first.",
+        fallback="Move lower-priority header copy into a disclosure block.",
+    ),
+    PressureGuardrailDefinition(
+        guardrail_id="guard_017_session",
+        surface="session",
+        trigger="session_pressure",
+        max_items=4,
+        collapsed_label="More session context",
+        expansion_label="Show session details",
+        reason="Limit session density so the reviewer sees the next decision first.",
+        fallback="Move lower-priority session copy into a disclosure block.",
+    ),
+    PressureGuardrailDefinition(
+        guardrail_id="guard_018_queue",
+        surface="queue",
+        trigger="queue_pressure",
+        max_items=5,
+        collapsed_label="More queue context",
+        expansion_label="Show queue details",
+        reason="Limit queue density so the reviewer sees the next decision first.",
+        fallback="Move lower-priority queue copy into a disclosure block.",
+    ),
+    PressureGuardrailDefinition(
+        guardrail_id="guard_019_detail",
+        surface="detail",
+        trigger="detail_pressure",
+        max_items=6,
+        collapsed_label="More detail context",
+        expansion_label="Show detail details",
+        reason="Limit detail density so the reviewer sees the next decision first.",
+        fallback="Move lower-priority detail copy into a disclosure block.",
+    ),
+    PressureGuardrailDefinition(
+        guardrail_id="guard_020_evidence",
+        surface="evidence",
+        trigger="evidence_pressure",
+        max_items=2,
+        collapsed_label="More evidence context",
+        expansion_label="Show evidence details",
+        reason="Limit evidence density so the reviewer sees the next decision first.",
+        fallback="Move lower-priority evidence copy into a disclosure block.",
+    ),
+    PressureGuardrailDefinition(
+        guardrail_id="guard_021_decision",
+        surface="decision",
+        trigger="decision_pressure",
+        max_items=3,
+        collapsed_label="More decision context",
+        expansion_label="Show decision details",
+        reason="Limit decision density so the reviewer sees the next decision first.",
+        fallback="Move lower-priority decision copy into a disclosure block.",
+    ),
+    PressureGuardrailDefinition(
+        guardrail_id="guard_022_diagnostics",
+        surface="diagnostics",
+        trigger="diagnostics_pressure",
+        max_items=4,
+        collapsed_label="More diagnostics context",
+        expansion_label="Show diagnostics details",
+        reason="Limit diagnostics density so the reviewer sees the next decision first.",
+        fallback="Move lower-priority diagnostics copy into a disclosure block.",
+    ),
+    PressureGuardrailDefinition(
+        guardrail_id="guard_023_report",
+        surface="report",
+        trigger="report_pressure",
+        max_items=5,
+        collapsed_label="More report context",
+        expansion_label="Show report details",
+        reason="Limit report density so the reviewer sees the next decision first.",
+        fallback="Move lower-priority report copy into a disclosure block.",
+    ),
+    PressureGuardrailDefinition(
+        guardrail_id="guard_024_header",
+        surface="header",
+        trigger="header_pressure",
+        max_items=6,
+        collapsed_label="More header context",
+        expansion_label="Show header details",
+        reason="Limit header density so the reviewer sees the next decision first.",
+        fallback="Move lower-priority header copy into a disclosure block.",
+    ),
+    PressureGuardrailDefinition(
+        guardrail_id="guard_025_session",
+        surface="session",
+        trigger="session_pressure",
+        max_items=2,
+        collapsed_label="More session context",
+        expansion_label="Show session details",
+        reason="Limit session density so the reviewer sees the next decision first.",
+        fallback="Move lower-priority session copy into a disclosure block.",
+    ),
+    PressureGuardrailDefinition(
+        guardrail_id="guard_026_queue",
+        surface="queue",
+        trigger="queue_pressure",
+        max_items=3,
+        collapsed_label="More queue context",
+        expansion_label="Show queue details",
+        reason="Limit queue density so the reviewer sees the next decision first.",
+        fallback="Move lower-priority queue copy into a disclosure block.",
+    ),
+    PressureGuardrailDefinition(
+        guardrail_id="guard_027_detail",
+        surface="detail",
+        trigger="detail_pressure",
+        max_items=4,
+        collapsed_label="More detail context",
+        expansion_label="Show detail details",
+        reason="Limit detail density so the reviewer sees the next decision first.",
+        fallback="Move lower-priority detail copy into a disclosure block.",
+    ),
+    PressureGuardrailDefinition(
+        guardrail_id="guard_028_evidence",
+        surface="evidence",
+        trigger="evidence_pressure",
+        max_items=5,
+        collapsed_label="More evidence context",
+        expansion_label="Show evidence details",
+        reason="Limit evidence density so the reviewer sees the next decision first.",
+        fallback="Move lower-priority evidence copy into a disclosure block.",
+    ),
+    PressureGuardrailDefinition(
+        guardrail_id="guard_029_decision",
+        surface="decision",
+        trigger="decision_pressure",
+        max_items=6,
+        collapsed_label="More decision context",
+        expansion_label="Show decision details",
+        reason="Limit decision density so the reviewer sees the next decision first.",
+        fallback="Move lower-priority decision copy into a disclosure block.",
+    ),
+    PressureGuardrailDefinition(
+        guardrail_id="guard_030_diagnostics",
+        surface="diagnostics",
+        trigger="diagnostics_pressure",
+        max_items=2,
+        collapsed_label="More diagnostics context",
+        expansion_label="Show diagnostics details",
+        reason="Limit diagnostics density so the reviewer sees the next decision first.",
+        fallback="Move lower-priority diagnostics copy into a disclosure block.",
+    ),
+    PressureGuardrailDefinition(
+        guardrail_id="guard_031_report",
+        surface="report",
+        trigger="report_pressure",
+        max_items=3,
+        collapsed_label="More report context",
+        expansion_label="Show report details",
+        reason="Limit report density so the reviewer sees the next decision first.",
+        fallback="Move lower-priority report copy into a disclosure block.",
+    ),
+    PressureGuardrailDefinition(
+        guardrail_id="guard_032_header",
+        surface="header",
+        trigger="header_pressure",
+        max_items=4,
+        collapsed_label="More header context",
+        expansion_label="Show header details",
+        reason="Limit header density so the reviewer sees the next decision first.",
+        fallback="Move lower-priority header copy into a disclosure block.",
+    ),
+    PressureGuardrailDefinition(
+        guardrail_id="guard_033_session",
+        surface="session",
+        trigger="session_pressure",
+        max_items=5,
+        collapsed_label="More session context",
+        expansion_label="Show session details",
+        reason="Limit session density so the reviewer sees the next decision first.",
+        fallback="Move lower-priority session copy into a disclosure block.",
+    ),
+    PressureGuardrailDefinition(
+        guardrail_id="guard_034_queue",
+        surface="queue",
+        trigger="queue_pressure",
+        max_items=6,
+        collapsed_label="More queue context",
+        expansion_label="Show queue details",
+        reason="Limit queue density so the reviewer sees the next decision first.",
+        fallback="Move lower-priority queue copy into a disclosure block.",
+    ),
+    PressureGuardrailDefinition(
+        guardrail_id="guard_035_detail",
+        surface="detail",
+        trigger="detail_pressure",
+        max_items=2,
+        collapsed_label="More detail context",
+        expansion_label="Show detail details",
+        reason="Limit detail density so the reviewer sees the next decision first.",
+        fallback="Move lower-priority detail copy into a disclosure block.",
+    ),
+    PressureGuardrailDefinition(
+        guardrail_id="guard_036_evidence",
+        surface="evidence",
+        trigger="evidence_pressure",
+        max_items=3,
+        collapsed_label="More evidence context",
+        expansion_label="Show evidence details",
+        reason="Limit evidence density so the reviewer sees the next decision first.",
+        fallback="Move lower-priority evidence copy into a disclosure block.",
+    ),
+    PressureGuardrailDefinition(
+        guardrail_id="guard_037_decision",
+        surface="decision",
+        trigger="decision_pressure",
+        max_items=4,
+        collapsed_label="More decision context",
+        expansion_label="Show decision details",
+        reason="Limit decision density so the reviewer sees the next decision first.",
+        fallback="Move lower-priority decision copy into a disclosure block.",
+    ),
+    PressureGuardrailDefinition(
+        guardrail_id="guard_038_diagnostics",
+        surface="diagnostics",
+        trigger="diagnostics_pressure",
+        max_items=5,
+        collapsed_label="More diagnostics context",
+        expansion_label="Show diagnostics details",
+        reason="Limit diagnostics density so the reviewer sees the next decision first.",
+        fallback="Move lower-priority diagnostics copy into a disclosure block.",
+    ),
+    PressureGuardrailDefinition(
+        guardrail_id="guard_039_report",
+        surface="report",
+        trigger="report_pressure",
+        max_items=6,
+        collapsed_label="More report context",
+        expansion_label="Show report details",
+        reason="Limit report density so the reviewer sees the next decision first.",
+        fallback="Move lower-priority report copy into a disclosure block.",
+    ),
+    PressureGuardrailDefinition(
+        guardrail_id="guard_040_header",
+        surface="header",
+        trigger="header_pressure",
+        max_items=2,
+        collapsed_label="More header context",
+        expansion_label="Show header details",
+        reason="Limit header density so the reviewer sees the next decision first.",
+        fallback="Move lower-priority header copy into a disclosure block.",
+    ),
+    PressureGuardrailDefinition(
+        guardrail_id="guard_041_session",
+        surface="session",
+        trigger="session_pressure",
+        max_items=3,
+        collapsed_label="More session context",
+        expansion_label="Show session details",
+        reason="Limit session density so the reviewer sees the next decision first.",
+        fallback="Move lower-priority session copy into a disclosure block.",
+    ),
+    PressureGuardrailDefinition(
+        guardrail_id="guard_042_queue",
+        surface="queue",
+        trigger="queue_pressure",
+        max_items=4,
+        collapsed_label="More queue context",
+        expansion_label="Show queue details",
+        reason="Limit queue density so the reviewer sees the next decision first.",
+        fallback="Move lower-priority queue copy into a disclosure block.",
+    ),
+    PressureGuardrailDefinition(
+        guardrail_id="guard_043_detail",
+        surface="detail",
+        trigger="detail_pressure",
+        max_items=5,
+        collapsed_label="More detail context",
+        expansion_label="Show detail details",
+        reason="Limit detail density so the reviewer sees the next decision first.",
+        fallback="Move lower-priority detail copy into a disclosure block.",
+    ),
+    PressureGuardrailDefinition(
+        guardrail_id="guard_044_evidence",
+        surface="evidence",
+        trigger="evidence_pressure",
+        max_items=6,
+        collapsed_label="More evidence context",
+        expansion_label="Show evidence details",
+        reason="Limit evidence density so the reviewer sees the next decision first.",
+        fallback="Move lower-priority evidence copy into a disclosure block.",
+    ),
+    PressureGuardrailDefinition(
+        guardrail_id="guard_045_decision",
+        surface="decision",
+        trigger="decision_pressure",
+        max_items=2,
+        collapsed_label="More decision context",
+        expansion_label="Show decision details",
+        reason="Limit decision density so the reviewer sees the next decision first.",
+        fallback="Move lower-priority decision copy into a disclosure block.",
+    ),
+    PressureGuardrailDefinition(
+        guardrail_id="guard_046_diagnostics",
+        surface="diagnostics",
+        trigger="diagnostics_pressure",
+        max_items=3,
+        collapsed_label="More diagnostics context",
+        expansion_label="Show diagnostics details",
+        reason="Limit diagnostics density so the reviewer sees the next decision first.",
+        fallback="Move lower-priority diagnostics copy into a disclosure block.",
+    ),
+    PressureGuardrailDefinition(
+        guardrail_id="guard_047_report",
+        surface="report",
+        trigger="report_pressure",
+        max_items=4,
+        collapsed_label="More report context",
+        expansion_label="Show report details",
+        reason="Limit report density so the reviewer sees the next decision first.",
+        fallback="Move lower-priority report copy into a disclosure block.",
+    ),
+    PressureGuardrailDefinition(
+        guardrail_id="guard_048_header",
+        surface="header",
+        trigger="header_pressure",
+        max_items=5,
+        collapsed_label="More header context",
+        expansion_label="Show header details",
+        reason="Limit header density so the reviewer sees the next decision first.",
+        fallback="Move lower-priority header copy into a disclosure block.",
+    ),
+    PressureGuardrailDefinition(
+        guardrail_id="guard_049_session",
+        surface="session",
+        trigger="session_pressure",
+        max_items=6,
+        collapsed_label="More session context",
+        expansion_label="Show session details",
+        reason="Limit session density so the reviewer sees the next decision first.",
+        fallback="Move lower-priority session copy into a disclosure block.",
+    ),
+    PressureGuardrailDefinition(
+        guardrail_id="guard_050_queue",
+        surface="queue",
+        trigger="queue_pressure",
+        max_items=2,
+        collapsed_label="More queue context",
+        expansion_label="Show queue details",
+        reason="Limit queue density so the reviewer sees the next decision first.",
+        fallback="Move lower-priority queue copy into a disclosure block.",
+    ),
+    PressureGuardrailDefinition(
+        guardrail_id="guard_051_detail",
+        surface="detail",
+        trigger="detail_pressure",
+        max_items=3,
+        collapsed_label="More detail context",
+        expansion_label="Show detail details",
+        reason="Limit detail density so the reviewer sees the next decision first.",
+        fallback="Move lower-priority detail copy into a disclosure block.",
+    ),
+    PressureGuardrailDefinition(
+        guardrail_id="guard_052_evidence",
+        surface="evidence",
+        trigger="evidence_pressure",
+        max_items=4,
+        collapsed_label="More evidence context",
+        expansion_label="Show evidence details",
+        reason="Limit evidence density so the reviewer sees the next decision first.",
+        fallback="Move lower-priority evidence copy into a disclosure block.",
+    ),
+    PressureGuardrailDefinition(
+        guardrail_id="guard_053_decision",
+        surface="decision",
+        trigger="decision_pressure",
+        max_items=5,
+        collapsed_label="More decision context",
+        expansion_label="Show decision details",
+        reason="Limit decision density so the reviewer sees the next decision first.",
+        fallback="Move lower-priority decision copy into a disclosure block.",
+    ),
+    PressureGuardrailDefinition(
+        guardrail_id="guard_054_diagnostics",
+        surface="diagnostics",
+        trigger="diagnostics_pressure",
+        max_items=6,
+        collapsed_label="More diagnostics context",
+        expansion_label="Show diagnostics details",
+        reason="Limit diagnostics density so the reviewer sees the next decision first.",
+        fallback="Move lower-priority diagnostics copy into a disclosure block.",
+    ),
+    PressureGuardrailDefinition(
+        guardrail_id="guard_055_report",
+        surface="report",
+        trigger="report_pressure",
+        max_items=2,
+        collapsed_label="More report context",
+        expansion_label="Show report details",
+        reason="Limit report density so the reviewer sees the next decision first.",
+        fallback="Move lower-priority report copy into a disclosure block.",
+    ),
+    PressureGuardrailDefinition(
+        guardrail_id="guard_056_header",
+        surface="header",
+        trigger="header_pressure",
+        max_items=3,
+        collapsed_label="More header context",
+        expansion_label="Show header details",
+        reason="Limit header density so the reviewer sees the next decision first.",
+        fallback="Move lower-priority header copy into a disclosure block.",
+    ),
+    PressureGuardrailDefinition(
+        guardrail_id="guard_057_session",
+        surface="session",
+        trigger="session_pressure",
+        max_items=4,
+        collapsed_label="More session context",
+        expansion_label="Show session details",
+        reason="Limit session density so the reviewer sees the next decision first.",
+        fallback="Move lower-priority session copy into a disclosure block.",
+    ),
+    PressureGuardrailDefinition(
+        guardrail_id="guard_058_queue",
+        surface="queue",
+        trigger="queue_pressure",
+        max_items=5,
+        collapsed_label="More queue context",
+        expansion_label="Show queue details",
+        reason="Limit queue density so the reviewer sees the next decision first.",
+        fallback="Move lower-priority queue copy into a disclosure block.",
+    ),
+    PressureGuardrailDefinition(
+        guardrail_id="guard_059_detail",
+        surface="detail",
+        trigger="detail_pressure",
+        max_items=6,
+        collapsed_label="More detail context",
+        expansion_label="Show detail details",
+        reason="Limit detail density so the reviewer sees the next decision first.",
+        fallback="Move lower-priority detail copy into a disclosure block.",
+    ),
+    PressureGuardrailDefinition(
+        guardrail_id="guard_060_evidence",
+        surface="evidence",
+        trigger="evidence_pressure",
+        max_items=2,
+        collapsed_label="More evidence context",
+        expansion_label="Show evidence details",
+        reason="Limit evidence density so the reviewer sees the next decision first.",
+        fallback="Move lower-priority evidence copy into a disclosure block.",
+    ),
+    PressureGuardrailDefinition(
+        guardrail_id="guard_061_decision",
+        surface="decision",
+        trigger="decision_pressure",
+        max_items=3,
+        collapsed_label="More decision context",
+        expansion_label="Show decision details",
+        reason="Limit decision density so the reviewer sees the next decision first.",
+        fallback="Move lower-priority decision copy into a disclosure block.",
+    ),
+    PressureGuardrailDefinition(
+        guardrail_id="guard_062_diagnostics",
+        surface="diagnostics",
+        trigger="diagnostics_pressure",
+        max_items=4,
+        collapsed_label="More diagnostics context",
+        expansion_label="Show diagnostics details",
+        reason="Limit diagnostics density so the reviewer sees the next decision first.",
+        fallback="Move lower-priority diagnostics copy into a disclosure block.",
+    ),
+    PressureGuardrailDefinition(
+        guardrail_id="guard_063_report",
+        surface="report",
+        trigger="report_pressure",
+        max_items=5,
+        collapsed_label="More report context",
+        expansion_label="Show report details",
+        reason="Limit report density so the reviewer sees the next decision first.",
+        fallback="Move lower-priority report copy into a disclosure block.",
+    ),
+    PressureGuardrailDefinition(
+        guardrail_id="guard_064_header",
+        surface="header",
+        trigger="header_pressure",
+        max_items=6,
+        collapsed_label="More header context",
+        expansion_label="Show header details",
+        reason="Limit header density so the reviewer sees the next decision first.",
+        fallback="Move lower-priority header copy into a disclosure block.",
+    ),
+    PressureGuardrailDefinition(
+        guardrail_id="guard_065_session",
+        surface="session",
+        trigger="session_pressure",
+        max_items=2,
+        collapsed_label="More session context",
+        expansion_label="Show session details",
+        reason="Limit session density so the reviewer sees the next decision first.",
+        fallback="Move lower-priority session copy into a disclosure block.",
+    ),
+    PressureGuardrailDefinition(
+        guardrail_id="guard_066_queue",
+        surface="queue",
+        trigger="queue_pressure",
+        max_items=3,
+        collapsed_label="More queue context",
+        expansion_label="Show queue details",
+        reason="Limit queue density so the reviewer sees the next decision first.",
+        fallback="Move lower-priority queue copy into a disclosure block.",
+    ),
+    PressureGuardrailDefinition(
+        guardrail_id="guard_067_detail",
+        surface="detail",
+        trigger="detail_pressure",
+        max_items=4,
+        collapsed_label="More detail context",
+        expansion_label="Show detail details",
+        reason="Limit detail density so the reviewer sees the next decision first.",
+        fallback="Move lower-priority detail copy into a disclosure block.",
+    ),
+    PressureGuardrailDefinition(
+        guardrail_id="guard_068_evidence",
+        surface="evidence",
+        trigger="evidence_pressure",
+        max_items=5,
+        collapsed_label="More evidence context",
+        expansion_label="Show evidence details",
+        reason="Limit evidence density so the reviewer sees the next decision first.",
+        fallback="Move lower-priority evidence copy into a disclosure block.",
+    ),
+    PressureGuardrailDefinition(
+        guardrail_id="guard_069_decision",
+        surface="decision",
+        trigger="decision_pressure",
+        max_items=6,
+        collapsed_label="More decision context",
+        expansion_label="Show decision details",
+        reason="Limit decision density so the reviewer sees the next decision first.",
+        fallback="Move lower-priority decision copy into a disclosure block.",
+    ),
+    PressureGuardrailDefinition(
+        guardrail_id="guard_070_diagnostics",
+        surface="diagnostics",
+        trigger="diagnostics_pressure",
+        max_items=2,
+        collapsed_label="More diagnostics context",
+        expansion_label="Show diagnostics details",
+        reason="Limit diagnostics density so the reviewer sees the next decision first.",
+        fallback="Move lower-priority diagnostics copy into a disclosure block.",
+    ),
+    PressureGuardrailDefinition(
+        guardrail_id="guard_071_report",
+        surface="report",
+        trigger="report_pressure",
+        max_items=3,
+        collapsed_label="More report context",
+        expansion_label="Show report details",
+        reason="Limit report density so the reviewer sees the next decision first.",
+        fallback="Move lower-priority report copy into a disclosure block.",
+    ),
+    PressureGuardrailDefinition(
+        guardrail_id="guard_072_header",
+        surface="header",
+        trigger="header_pressure",
+        max_items=4,
+        collapsed_label="More header context",
+        expansion_label="Show header details",
+        reason="Limit header density so the reviewer sees the next decision first.",
+        fallback="Move lower-priority header copy into a disclosure block.",
+    ),
+    PressureGuardrailDefinition(
+        guardrail_id="guard_073_session",
+        surface="session",
+        trigger="session_pressure",
+        max_items=5,
+        collapsed_label="More session context",
+        expansion_label="Show session details",
+        reason="Limit session density so the reviewer sees the next decision first.",
+        fallback="Move lower-priority session copy into a disclosure block.",
+    ),
+    PressureGuardrailDefinition(
+        guardrail_id="guard_074_queue",
+        surface="queue",
+        trigger="queue_pressure",
+        max_items=6,
+        collapsed_label="More queue context",
+        expansion_label="Show queue details",
+        reason="Limit queue density so the reviewer sees the next decision first.",
+        fallback="Move lower-priority queue copy into a disclosure block.",
+    ),
+    PressureGuardrailDefinition(
+        guardrail_id="guard_075_detail",
+        surface="detail",
+        trigger="detail_pressure",
+        max_items=2,
+        collapsed_label="More detail context",
+        expansion_label="Show detail details",
+        reason="Limit detail density so the reviewer sees the next decision first.",
+        fallback="Move lower-priority detail copy into a disclosure block.",
+    ),
+    PressureGuardrailDefinition(
+        guardrail_id="guard_076_evidence",
+        surface="evidence",
+        trigger="evidence_pressure",
+        max_items=3,
+        collapsed_label="More evidence context",
+        expansion_label="Show evidence details",
+        reason="Limit evidence density so the reviewer sees the next decision first.",
+        fallback="Move lower-priority evidence copy into a disclosure block.",
+    ),
+    PressureGuardrailDefinition(
+        guardrail_id="guard_077_decision",
+        surface="decision",
+        trigger="decision_pressure",
+        max_items=4,
+        collapsed_label="More decision context",
+        expansion_label="Show decision details",
+        reason="Limit decision density so the reviewer sees the next decision first.",
+        fallback="Move lower-priority decision copy into a disclosure block.",
+    ),
+    PressureGuardrailDefinition(
+        guardrail_id="guard_078_diagnostics",
+        surface="diagnostics",
+        trigger="diagnostics_pressure",
+        max_items=5,
+        collapsed_label="More diagnostics context",
+        expansion_label="Show diagnostics details",
+        reason="Limit diagnostics density so the reviewer sees the next decision first.",
+        fallback="Move lower-priority diagnostics copy into a disclosure block.",
+    ),
+    PressureGuardrailDefinition(
+        guardrail_id="guard_079_report",
+        surface="report",
+        trigger="report_pressure",
+        max_items=6,
+        collapsed_label="More report context",
+        expansion_label="Show report details",
+        reason="Limit report density so the reviewer sees the next decision first.",
+        fallback="Move lower-priority report copy into a disclosure block.",
+    ),
+    PressureGuardrailDefinition(
+        guardrail_id="guard_080_header",
+        surface="header",
+        trigger="header_pressure",
+        max_items=2,
+        collapsed_label="More header context",
+        expansion_label="Show header details",
+        reason="Limit header density so the reviewer sees the next decision first.",
+        fallback="Move lower-priority header copy into a disclosure block.",
+    ),
+    PressureGuardrailDefinition(
+        guardrail_id="guard_081_session",
+        surface="session",
+        trigger="session_pressure",
+        max_items=3,
+        collapsed_label="More session context",
+        expansion_label="Show session details",
+        reason="Limit session density so the reviewer sees the next decision first.",
+        fallback="Move lower-priority session copy into a disclosure block.",
+    ),
+    PressureGuardrailDefinition(
+        guardrail_id="guard_082_queue",
+        surface="queue",
+        trigger="queue_pressure",
+        max_items=4,
+        collapsed_label="More queue context",
+        expansion_label="Show queue details",
+        reason="Limit queue density so the reviewer sees the next decision first.",
+        fallback="Move lower-priority queue copy into a disclosure block.",
+    ),
+    PressureGuardrailDefinition(
+        guardrail_id="guard_083_detail",
+        surface="detail",
+        trigger="detail_pressure",
+        max_items=5,
+        collapsed_label="More detail context",
+        expansion_label="Show detail details",
+        reason="Limit detail density so the reviewer sees the next decision first.",
+        fallback="Move lower-priority detail copy into a disclosure block.",
+    ),
+    PressureGuardrailDefinition(
+        guardrail_id="guard_084_evidence",
+        surface="evidence",
+        trigger="evidence_pressure",
+        max_items=6,
+        collapsed_label="More evidence context",
+        expansion_label="Show evidence details",
+        reason="Limit evidence density so the reviewer sees the next decision first.",
+        fallback="Move lower-priority evidence copy into a disclosure block.",
+    ),
+    PressureGuardrailDefinition(
+        guardrail_id="guard_085_decision",
+        surface="decision",
+        trigger="decision_pressure",
+        max_items=2,
+        collapsed_label="More decision context",
+        expansion_label="Show decision details",
+        reason="Limit decision density so the reviewer sees the next decision first.",
+        fallback="Move lower-priority decision copy into a disclosure block.",
+    ),
+    PressureGuardrailDefinition(
+        guardrail_id="guard_086_diagnostics",
+        surface="diagnostics",
+        trigger="diagnostics_pressure",
+        max_items=3,
+        collapsed_label="More diagnostics context",
+        expansion_label="Show diagnostics details",
+        reason="Limit diagnostics density so the reviewer sees the next decision first.",
+        fallback="Move lower-priority diagnostics copy into a disclosure block.",
+    ),
+    PressureGuardrailDefinition(
+        guardrail_id="guard_087_report",
+        surface="report",
+        trigger="report_pressure",
+        max_items=4,
+        collapsed_label="More report context",
+        expansion_label="Show report details",
+        reason="Limit report density so the reviewer sees the next decision first.",
+        fallback="Move lower-priority report copy into a disclosure block.",
+    ),
+    PressureGuardrailDefinition(
+        guardrail_id="guard_088_header",
+        surface="header",
+        trigger="header_pressure",
+        max_items=5,
+        collapsed_label="More header context",
+        expansion_label="Show header details",
+        reason="Limit header density so the reviewer sees the next decision first.",
+        fallback="Move lower-priority header copy into a disclosure block.",
+    ),
+    PressureGuardrailDefinition(
+        guardrail_id="guard_089_session",
+        surface="session",
+        trigger="session_pressure",
+        max_items=6,
+        collapsed_label="More session context",
+        expansion_label="Show session details",
+        reason="Limit session density so the reviewer sees the next decision first.",
+        fallback="Move lower-priority session copy into a disclosure block.",
+    ),
+    PressureGuardrailDefinition(
+        guardrail_id="guard_090_queue",
+        surface="queue",
+        trigger="queue_pressure",
+        max_items=2,
+        collapsed_label="More queue context",
+        expansion_label="Show queue details",
+        reason="Limit queue density so the reviewer sees the next decision first.",
+        fallback="Move lower-priority queue copy into a disclosure block.",
+    ),
+    PressureGuardrailDefinition(
+        guardrail_id="guard_091_detail",
+        surface="detail",
+        trigger="detail_pressure",
+        max_items=3,
+        collapsed_label="More detail context",
+        expansion_label="Show detail details",
+        reason="Limit detail density so the reviewer sees the next decision first.",
+        fallback="Move lower-priority detail copy into a disclosure block.",
+    ),
+    PressureGuardrailDefinition(
+        guardrail_id="guard_092_evidence",
+        surface="evidence",
+        trigger="evidence_pressure",
+        max_items=4,
+        collapsed_label="More evidence context",
+        expansion_label="Show evidence details",
+        reason="Limit evidence density so the reviewer sees the next decision first.",
+        fallback="Move lower-priority evidence copy into a disclosure block.",
+    ),
+    PressureGuardrailDefinition(
+        guardrail_id="guard_093_decision",
+        surface="decision",
+        trigger="decision_pressure",
+        max_items=5,
+        collapsed_label="More decision context",
+        expansion_label="Show decision details",
+        reason="Limit decision density so the reviewer sees the next decision first.",
+        fallback="Move lower-priority decision copy into a disclosure block.",
+    ),
+    PressureGuardrailDefinition(
+        guardrail_id="guard_094_diagnostics",
+        surface="diagnostics",
+        trigger="diagnostics_pressure",
+        max_items=6,
+        collapsed_label="More diagnostics context",
+        expansion_label="Show diagnostics details",
+        reason="Limit diagnostics density so the reviewer sees the next decision first.",
+        fallback="Move lower-priority diagnostics copy into a disclosure block.",
+    ),
+    PressureGuardrailDefinition(
+        guardrail_id="guard_095_report",
+        surface="report",
+        trigger="report_pressure",
+        max_items=2,
+        collapsed_label="More report context",
+        expansion_label="Show report details",
+        reason="Limit report density so the reviewer sees the next decision first.",
+        fallback="Move lower-priority report copy into a disclosure block.",
+    ),
+)
+
+
+def rules_for_dimension(dimension: str) -> list[TrustRuleDefinition]:
+    return [rule for rule in TRUST_RULE_DEFINITIONS if rule.dimension == dimension]
+
+
+def rules_for_match(match_key: str, match_value: str) -> list[TrustRuleDefinition]:
+    return [
+        rule for rule in TRUST_RULE_DEFINITIONS
+        if rule.match_key == match_key and rule.match_value == match_value
+    ]
+
+
+def evidence_patterns_for_relation(relation: str) -> list[EvidenceCompressionPattern]:
+    matches = [pattern for pattern in EVIDENCE_COMPRESSION_PATTERNS if pattern.relation == relation]
+    return sorted(matches, key=lambda pattern: pattern.priority)
+
+
+def evidence_patterns_for_bucket(bucket: str) -> list[EvidenceCompressionPattern]:
+    matches = [pattern for pattern in EVIDENCE_COMPRESSION_PATTERNS if pattern.bucket == bucket]
+    return sorted(matches, key=lambda pattern: pattern.priority)
+
+
+def decision_impacts_for_action(action: str) -> list[DecisionImpactDefinition]:
+    return [impact for impact in DECISION_IMPACT_DEFINITIONS if impact.action == action]
+
+
+def first_decision_impact(action: str) -> DecisionImpactDefinition:
+    matches = decision_impacts_for_action(action)
+    if matches:
+        return matches[0]
+    return DECISION_IMPACT_DEFINITIONS[0]
+
+
+def review_path_templates_for_stage(stage: str) -> list[ReviewPathTemplate]:
+    return [template for template in REVIEW_PATH_TEMPLATES if template.stage == stage]
+
+
+def report_sections_for_trigger(trigger: str) -> list[ReportSectionDefinition]:
+    return [section for section in REPORT_SECTION_DEFINITIONS if section.trigger == trigger]
+
+
+def report_sections_by_priority(limit: int = 8) -> list[ReportSectionDefinition]:
+    return sorted(REPORT_SECTION_DEFINITIONS, key=lambda section: (section.priority, section.section_id))[:limit]
+
+
+def session_mode_definition(mode_id: str) -> SessionModeDefinition:
+    for mode in SESSION_MODE_DEFINITIONS:
+        if mode.mode_id == mode_id:
+            return mode
+    return SESSION_MODE_DEFINITIONS[0]
+
+
+def pressure_guardrails_for_surface(surface: str) -> list[PressureGuardrailDefinition]:
+    return [guardrail for guardrail in PRESSURE_GUARDRAIL_DEFINITIONS if guardrail.surface == surface]
+
+
+def pressure_guardrails_for_surfaces(surfaces: Iterable[str]) -> list[PressureGuardrailDefinition]:
+    wanted = set(surfaces)
+    return [guardrail for guardrail in PRESSURE_GUARDRAIL_DEFINITIONS if guardrail.surface in wanted]
diff --git a/tests/test_trust_center.py b/tests/test_trust_center.py
index 51d06a6..504caf2 100644
--- a/tests/test_trust_center.py
+++ b/tests/test_trust_center.py
@@ -51,6 +51,48 @@ def test_trust_review_queue_exposes_session_decision_fields(
     assert any(option["requires_rewrite"] for option in item["decision_options"])
 
 
+def test_trust_review_queue_exposes_engine_3_payload(
+    tmp_path: Path,
+    monkeypatch,
+) -> None:
+    monkeypatch.chdir(tmp_path)
+    client = TestClient(app)
+    client.post("/api/demo/load")
+
+    payload = client.get("/api/trust/review").json()
+    item = payload["items"][0]
+
+    assert payload["session"]["mode"] == "high-risk"
+    assert payload["session"]["recommended_source_ids"]
+    assert payload["session"]["next_step"]["source_id"] == item["source_id"]
+    assert payload["report"]["headline"]
+    assert payload["report"]["sections"]
+    assert item["analysis"]["trust_score"]["label"]
+    assert item["analysis"]["evidence_compression"]["supporting"]
+    assert item["analysis"]["decision_preview"]["confirmed"]["summary"]
+    assert item["analysis"]["review_path"]["steps"]
+    assert item["analysis"]["quiet_summary"]
+
+
+def test_trust_review_detail_exposes_compressed_evidence_and_preview(
+    tmp_path: Path,
+    monkeypatch,
+) -> None:
+    monkeypatch.chdir(tmp_path)
+    client = TestClient(app)
+    client.post("/api/demo/load")
+    source_id = client.get("/api/trust/review").json()["items"][0]["source_id"]
+
+    detail = client.get(f"/api/trust/review/{source_id}").json()
+
+    assert detail["analysis"]["source_id"] == source_id
+    assert detail["analysis"]["evidence_compression"]["summary"]
+    assert detail["analysis"]["decision_preview"]["rejected"]["warnings"]
+    assert detail["analysis"]["session_fit"]["reason"]
+    assert detail["analysis"]["impact_map"]["future_recall"]
+    assert detail["report_slice"]["recommended_action"]
+
+
 def test_trust_review_detail_exposes_traceability(tmp_path: Path, monkeypatch) -> None:
     monkeypatch.chdir(tmp_path)
     client = TestClient(app)
diff --git a/tests/trust_operations_ui.test.ts b/tests/trust_operations_ui.test.ts
index 173001c..cfdcd4a 100644
--- a/tests/trust_operations_ui.test.ts
+++ b/tests/trust_operations_ui.test.ts
@@ -179,3 +179,24 @@ test('Trust Center secondary panels include guidance and responsive session layo
   assert.match(styles, /\.trust-loop-priority-note/)
   assert.match(styles, /\.trust-diagnostics-guidance/)
 })
+
+test('Trust Center exposes engine 3 analysis without adding visual pressure', () => {
+  const view = read('frontend/src/components/TrustCenterView.vue')
+  const detail = read('frontend/src/components/TrustReviewDetail.vue')
+  const report = read('frontend/src/components/TrustQuietReport.vue')
+  const digest = read('frontend/src/components/TrustAnalysisDigest.vue')
+  const types = read('frontend/src/components/trustCenterTypes.ts')
+  const styles = read('frontend/src/styles.css')
+
+  assert.match(types, /TrustEngineAnalysis/)
+  assert.match(types, /TrustSessionPayload/)
+  assert.match(types, /TrustReportPayload/)
+  assert.match(view, /TrustQuietReport/)
+  assert.match(detail, /TrustAnalysisDigest/)
+  assert.match(report, /trust-quiet-report/)
+  assert.match(report, /<details/)
+  assert.match(digest, /trust-analysis-digest/)
+  assert.match(digest, /evidence_compression/)
+  assert.match(styles, /\.trust-quiet-report/)
+  assert.match(styles, /\.trust-analysis-digest/)
+})