@cat-factory/app 0.157.0 → 0.158.0

package/app/components/layout/NotificationsInbox.vue

@@ -1,5 +1,6 @@
 <script setup lang="ts">
 import type { Notification } from '~/types/domain'
+import type { ReviewEffort } from '~/types/merge'
 
 // The board's notification inbox: a bell with an open-count badge that opens a
 // panel of human-actionable items (a PR awaiting a merge decision, a completed
@@ -13,6 +14,7 @@ const notifications = useNotificationsStore()
 const ui = useUiStore()
 const access = useWorkspaceAccess()
 const execution = useExecutionStore()
+const trackRecords = useMergeTrackRecordsStore()
 const toast = useToast()
 
 const busy = ref<string | null>(null)
@@ -34,6 +36,10 @@ type Accent = 'warning' | 'primary' | 'error'
 const META: Record<Notification['type'], { icon: string; color: Accent }> = {
   merge_review: { icon: 'i-lucide-git-pull-request-arrow', color: 'warning' },
   pipeline_complete: { icon: 'i-lucide-circle-check', color: 'primary' },
+  // A PR merged directly on the provider left its merge track record untagged. Purely a nudge:
+  // "act" records the picked reviewer effort (nothing at all if none was picked) and dismissing
+  // it is always fine — the record stays valid untagged.
+  merge_tag_request: { icon: 'i-lucide-tag', color: 'primary' },
   ci_failed: { icon: 'i-lucide-triangle-alert', color: 'error' },
   test_failed: { icon: 'i-lucide-flask-conical', color: 'error' },
   // Clicking the title opens the review window for the task (see `reveal`); "act" just marks
@@ -89,6 +95,7 @@ const META: Record<Notification['type'], { icon: string; color: Accent }> = {
 const ACTION_KEYS: Record<Notification['type'], string> = {
   merge_review: 'layout.notifications.action.merge_review',
   pipeline_complete: 'layout.notifications.action.pipeline_complete',
+  merge_tag_request: 'layout.notifications.action.merge_tag_request',
   ci_failed: 'layout.notifications.action.ci_failed',
   test_failed: 'layout.notifications.action.test_failed',
   requirement_review: 'layout.notifications.action.requirement_review',
@@ -127,10 +134,57 @@ function accent(n: Notification): Accent {
   return isUrgent(n) ? 'error' : META[n.type].color
 }
 
+/**
+ * Which cards collect a reviewer-effort tag: the two that MERGE a PR, plus the post-hoc nudge for
+ * one that was merged on the provider. Everything else has nothing to tag.
+ */
+function collectsEffort(n: Notification): boolean {
+  return (
+    n.type === 'merge_review' || n.type === 'pipeline_complete' || n.type === 'merge_tag_request'
+  )
+}
+
+/**
+ * The human's picked effort per card, preselected from evidence rather than starting blank: if the
+ * run's `pr-reviewer` step actually recorded findings, review comments plausibly drove rework
+ * (`minor`); if it did not, the PR needed nothing (`none`). One tap either confirms that guess or
+ * corrects it. `undefined` means the card collects no tag at all.
+ */
+const effortByCard = reactive<Record<string, ReviewEffort | null>>({})
+
+/** Whether the run's PR review surfaced any findings — the default-preselection signal. */
+function hadReviewFindings(n: Notification): boolean {
+  const instance = n.executionId ? execution.getInstance(n.executionId) : undefined
+  return (instance?.steps ?? []).some((s) => (s.prReview?.findings?.length ?? 0) > 0)
+}
+
+function effortFor(n: Notification): ReviewEffort | null {
+  if (!(n.id in effortByCard)) effortByCard[n.id] = hadReviewFindings(n) ? 'minor' : 'none'
+  return effortByCard[n.id] ?? null
+}
+
+/** The change class the engine recorded for the run, when classification resolved one. */
+function changeClassOf(n: Notification) {
+  return n.payload?.changeClass
+}
+
+// Load the per-class rollups ONCE, the first time an effort-collecting card is in the inbox, so a
+// merge card can show what that class has historically needed. Not part of the workspace snapshot
+// (it's settings-screen/card context, not board state) and a single request for every class.
+watch(
+  () => notifications.open.some(collectsEffort),
+  (needed) => {
+    if (needed && !trackRecords.loaded && !trackRecords.loading) void trackRecords.load()
+  },
+  { immediate: true },
+)
+
 async function act(n: Notification) {
   busy.value = n.id
   try {
-    await notifications.act(n.id)
+    // Only the merge cards carry a tag; passing `undefined` elsewhere keeps the historical
+    // no-body act, so a non-merge card's action is completely unchanged.
+    await notifications.act(n.id, collectsEffort(n) ? effortFor(n) : undefined)
     toast.add({
       title: t('layout.notifications.toast.acted'),
       color: 'success',
@@ -327,6 +381,14 @@ function revealDecision(n: Notification) {
                 <UIcon name="i-lucide-external-link" class="h-3 w-3" />
                 {{ t('layout.notifications.openPr') }}
               </a>
+              <MergeEffortChips
+                v-if="collectsEffort(n)"
+                :model-value="effortFor(n)"
+                :change-class="changeClassOf(n)"
+                :rollup="changeClassOf(n) ? trackRecords.byClass[changeClassOf(n)!] : null"
+                :disabled="busy === n.id || !access.canExecuteRuns.value"
+                @update:model-value="effortByCard[n.id] = $event"
+              />
               <div class="mt-2 flex items-center gap-1.5">
                 <UButton
                   data-testid="notification-act"

package/app/components/merge/MergeEffortChips.vue

@@ -0,0 +1,122 @@
+<script setup lang="ts">
+// The reviewer-effort tag picker: ONE TAP, not a form. Shown on a merge-decision card (and the
+// external-merge nudge) so the human who confirms a merge also records how much review the PR
+// actually needed — the ground truth the auto-merge score thresholds are trying to approximate.
+//
+// Tagging is never mandatory: the parent can always act without a selection, and an untagged
+// merge records a null tag. This component only chooses; the parent performs the action.
+//
+// See docs/initiatives/merge-track-record.md.
+import { computed } from 'vue'
+import { REVIEW_EFFORTS } from '@cat-factory/contracts'
+import type { ChangeClass, MergeClassRollup, ReviewEffort } from '~/types/merge'
+
+const props = defineProps<{
+  /** The currently picked effort, or null for "not chosen". */
+  modelValue: ReviewEffort | null
+  /** The run's change class, when classification resolved one — shown as context. */
+  changeClass?: ChangeClass
+  /** That class's accumulated track record, so the human sees what the class usually needs. */
+  rollup?: MergeClassRollup | null
+  disabled?: boolean
+}>()
+
+const emit = defineEmits<{ 'update:modelValue': [ReviewEffort | null] }>()
+
+const { t, n } = useI18n()
+
+// Per-effort label + icon. Exhaustive Records keyed off the union (a missing member fails the
+// typecheck) with LITERAL catalog keys so the typed-message-keys check sees them; leaf keys
+// mirror the enum value verbatim.
+const EFFORT_LABEL_KEYS: Record<ReviewEffort, string> = {
+  none: 'merge.effort.none',
+  minor: 'merge.effort.minor',
+  major: 'merge.effort.major',
+}
+const EFFORT_ICONS: Record<ReviewEffort, string> = {
+  none: 'i-lucide-check',
+  minor: 'i-lucide-pencil-line',
+  major: 'i-lucide-hammer',
+}
+
+// Per-class label. Same exhaustive-Record discipline; `unknown` is included because a card can
+// carry no class at all (classification unavailable) and the caller may still render context.
+const CLASS_LABEL_KEYS: Record<ChangeClass, string> = {
+  docs: 'merge.changeClass.docs',
+  test: 'merge.changeClass.test',
+  dependency: 'merge.changeClass.dependency',
+  config: 'merge.changeClass.config',
+  source: 'merge.changeClass.source',
+  schema: 'merge.changeClass.schema',
+  unknown: 'merge.changeClass.unknown',
+}
+
+const chips = computed(() =>
+  REVIEW_EFFORTS.map((effort) => ({
+    effort,
+    label: t(EFFORT_LABEL_KEYS[effort]),
+    icon: EFFORT_ICONS[effort],
+  })),
+)
+
+const classLabel = computed(() =>
+  props.changeClass ? t(CLASS_LABEL_KEYS[props.changeClass]) : null,
+)
+
+/**
+ * The class's history line — how many of this class have landed and what share auto-merged. Null
+ * until the class has at least one landed record, so a fresh workspace shows nothing rather than
+ * a misleading "0%".
+ */
+const history = computed(() => {
+  const r = props.rollup
+  if (!r || r.merged === 0) return null
+  // Percentages go through vue-i18n's named `percent` format, never a hand-rolled `* 100 + '%'`.
+  return t('merge.effort.classHistory', {
+    merged: r.merged,
+    autoShare: n(r.autoMerged / r.merged, 'percent'),
+  })
+})
+
+/** Toggle: tapping the picked chip clears the tag (back to untagged). */
+function pick(effort: ReviewEffort) {
+  emit('update:modelValue', props.modelValue === effort ? null : effort)
+}
+</script>
+
+<template>
+  <div data-testid="merge-effort-chips" class="mt-2">
+    <div class="flex items-center gap-1.5">
+      <span class="text-[10px] uppercase tracking-wide text-slate-500">
+        {{ t('merge.effort.prompt') }}
+      </span>
+      <UBadge
+        v-if="classLabel"
+        data-testid="merge-effort-class"
+        color="neutral"
+        variant="subtle"
+        size="sm"
+      >
+        {{ classLabel }}
+      </UBadge>
+    </div>
+    <div class="mt-1 flex flex-wrap items-center gap-1">
+      <UButton
+        v-for="chip in chips"
+        :key="chip.effort"
+        :data-testid="`merge-effort-${chip.effort}`"
+        :color="modelValue === chip.effort ? 'primary' : 'neutral'"
+        :variant="modelValue === chip.effort ? 'solid' : 'outline'"
+        size="xs"
+        :icon="chip.icon"
+        :disabled="disabled"
+        @click="pick(chip.effort)"
+      >
+        {{ chip.label }}
+      </UButton>
+    </div>
+    <p v-if="history" data-testid="merge-effort-history" class="mt-1 text-[10px] text-slate-500">
+      {{ history }}
+    </p>
+  </div>
+</template>

package/app/components/panels/MergerResultView.vue

@@ -7,7 +7,7 @@
 // banner — instead of the agent's raw JSON. Opened via the universal result-view host,
 // the same seam the requirements / tester windows use.
 import { computed } from 'vue'
-import type { MergeAxis, MergeDecision } from '@cat-factory/contracts'
+import type { ChangeClass, MergeAxis, MergeDecision } from '@cat-factory/contracts'
 import StepRunMeta from '~/components/panels/StepRunMeta.vue'
 import ResultWindowShell from '~/components/panels/ResultWindowShell.vue'
 import MarkdownProse from '~/components/common/MarkdownProse.vue'
@@ -68,6 +68,8 @@ const REASON_KEYS: Record<MergeDecision['reason'], string> = {
   no_assessment: 'panels.mergerResult.reason.no_assessment',
   merge_failed: 'panels.mergerResult.reason.merge_failed',
   merge_partial: 'panels.mergerResult.reason.merge_partial',
+  class_auto_merge: 'panels.mergerResult.reason.class_auto_merge',
+  class_requires_review: 'panels.mergerResult.reason.class_requires_review',
 }
 const OUTCOME_KEYS: Record<MergeDecision['outcome'], string> = {
   auto_merged: 'panels.mergerResult.outcome.auto_merged',
@@ -81,6 +83,28 @@ const AXIS_KEYS: Record<MergeAxis, string> = {
 
 const outcomeText = computed(() => (decision.value ? t(OUTCOME_KEYS[decision.value.outcome]) : ''))
 
+// Per-change-class label — exhaustive over the union so a new class fails typecheck here until it
+// has a key. Only the classes a decision can actually carry are reachable (`unknown` never lands
+// on a decision: the engine omits the field instead), but the map stays total by construction.
+const CLASS_KEYS: Record<ChangeClass, string> = {
+  docs: 'merge.changeClass.docs',
+  test: 'merge.changeClass.test',
+  dependency: 'merge.changeClass.dependency',
+  config: 'merge.changeClass.config',
+  source: 'merge.changeClass.source',
+  schema: 'merge.changeClass.schema',
+  unknown: 'merge.changeClass.unknown',
+}
+
+/**
+ * The DETERMINISTIC change class the engine derived from the PR's changed files, when it resolved
+ * one. Shown beside the outcome so a reader sees WHAT KIND of change the decision was made about —
+ * which is what a `class_auto_merge` / `class_requires_review` reason is actually keyed on.
+ */
+const changeClassLabel = computed(() =>
+  decision.value?.changeClass ? t(CLASS_KEYS[decision.value.changeClass]) : null,
+)
+
 /** The three axes with their score + preset ceiling, for the bar rows. */
 const axes = computed(() => {
   const d = decision.value
@@ -150,12 +174,23 @@ const reasonText = computed(() => {
               :class="merged ? 'text-emerald-300' : 'text-amber-300'"
             />
             <div class="min-w-0">
-              <p
-                class="text-sm font-semibold"
-                :class="merged ? 'text-emerald-200' : 'text-amber-200'"
-              >
-                {{ outcomeText }}
-              </p>
+              <div class="flex flex-wrap items-center gap-2">
+                <p
+                  class="text-sm font-semibold"
+                  :class="merged ? 'text-emerald-200' : 'text-amber-200'"
+                >
+                  {{ outcomeText }}
+                </p>
+                <UBadge
+                  v-if="changeClassLabel"
+                  data-testid="merger-change-class"
+                  color="neutral"
+                  variant="subtle"
+                  size="sm"
+                >
+                  {{ changeClassLabel }}
+                </UBadge>
+              </div>
               <p class="mt-0.5 text-[13px] leading-relaxed text-slate-300">{{ reasonText }}</p>
             </div>
           </div>

package/app/components/panels/inspector/TaskExecution.vue

@@ -13,6 +13,8 @@ import EmptyState from '~/components/common/EmptyState.vue'
 import InspectorSection from '~/components/panels/inspector/InspectorSection.vue'
 import { useNowTick, stepDurationLabel } from '~/composables/useStepTimer'
 import type { PipelineStep } from '~/types/execution'
+import type { ChangeClass, ReviewEffort } from '~/types/merge'
+import MergeEffortChips from '~/components/merge/MergeEffortChips.vue'
 
 const props = defineProps<{ block: Block }>()
 
@@ -21,6 +23,7 @@ const agentRuns = useAgentRunsStore()
 const ui = useUiStore()
 const models = useModelsStore()
 const reviews = useReviewStage()
+const trackRecords = useMergeTrackRecordsStore()
 const access = useWorkspaceAccess()
 const { t, te } = useI18n()
 const { confirm } = useConfirm()
@@ -203,6 +206,39 @@ async function resetRun() {
   }
 }
 
+/**
+ * The reviewer-effort tag for this merge, preselected from evidence rather than starting blank: if
+ * the run's `pr-reviewer` step recorded findings, review comments plausibly drove rework
+ * (`minor`); if it did not, the PR needed nothing (`none`). One tap confirms or corrects it, and
+ * `null` merges untagged — tagging is a nudge, never a gate.
+ */
+const mergeEffort = ref<ReviewEffort | null>(null)
+
+watch(
+  () => props.block.status === 'pr_ready',
+  (awaiting) => {
+    if (!awaiting) return
+    // ONE request for every class, only once and only when a merge decision is actually pending.
+    if (!trackRecords.loaded && !trackRecords.loading) void trackRecords.load()
+    // Preselect from evidence rather than leaving it blank. Set HERE (not at setup) because the
+    // run instance may still be loading when this component first mounts.
+    mergeEffort.value ??= (instance.value?.steps ?? []).some(
+      (s) => (s.prReview?.findings?.length ?? 0) > 0,
+    )
+      ? 'minor'
+      : 'none'
+  },
+  { immediate: true },
+)
+
+/** The change class the engine recorded on the run's merger step, when one resolved. */
+const mergeChangeClass = computed<ChangeClass | undefined>(() => {
+  const decision = instance.value?.steps.find((s) => s.agentKind === 'merger')?.custom as
+    | { changeClass?: ChangeClass }
+    | undefined
+  return decision?.changeClass
+})
+
 // Merging a PR is consequential and effectively irreversible — confirm first. `execution.mergePr`
 // surfaces its own error toast, so no catch is needed here.
 async function mergePr() {
@@ -213,7 +249,7 @@ async function mergePr() {
     icon: 'i-lucide-git-merge',
   })
   if (!ok) return
-  await execution.mergePr(props.block.id)
+  await execution.mergePr(props.block.id, mergeEffort.value)
 }
 </script>
 
@@ -548,17 +584,25 @@ async function mergePr() {
       :description="t('inspector.execution.empty.body')"
     />
 
-    <!-- PR ready: merge -->
-    <UButton
-      v-if="block.status === 'pr_ready'"
-      color="success"
-      variant="solid"
-      size="sm"
-      icon="i-lucide-git-merge"
-      block
-      @click="mergePr"
-    >
-      {{ t('inspector.execution.mergePr') }}
-    </UButton>
+    <!-- PR ready: record how much review it needed, then merge. -->
+    <template v-if="block.status === 'pr_ready'">
+      <MergeEffortChips
+        v-model="mergeEffort"
+        :change-class="mergeChangeClass"
+        :rollup="mergeChangeClass ? trackRecords.byClass[mergeChangeClass] : null"
+      />
+      <UButton
+        class="mt-2"
+        color="success"
+        variant="solid"
+        size="sm"
+        icon="i-lucide-git-merge"
+        block
+        data-testid="inspector-merge-pr"
+        @click="mergePr"
+      >
+        {{ t('inspector.execution.mergePr') }}
+      </UButton>
+    </template>
   </InspectorSection>
 </template>

package/app/components/settings/MergeClassRulesEditor.vue

@@ -0,0 +1,140 @@
+<script setup lang="ts">
+// Per-change-class auto-merge rules for one merge preset, shown NEXT TO each class's accumulated
+// track record — the number that justifies widening a rule. That pairing is the whole point: an
+// operator flips `docs` to "always auto-merge" because the history says humans found nothing to
+// say about docs changes, not on a hunch.
+//
+// `unknown` is deliberately not listed: no rule may ever match it (an unclassifiable diff must
+// fall back to the score ceilings), so offering one would be a lie. See
+// docs/initiatives/merge-track-record.md.
+import { computed } from 'vue'
+import { autoMergeShare, frictionlessShare, RULEABLE_CHANGE_CLASSES } from '@cat-factory/contracts'
+import type { MergeClassRule, MergeClassRules } from '~/types/merge'
+
+const props = defineProps<{
+  /** The preset's current rules; an absent class means "use the score ceilings". */
+  modelValue: MergeClassRules
+  /** Whether the preset auto-merges at all — a rule can never override `autoMergeEnabled: false`. */
+  autoMergeEnabled: boolean
+  disabled?: boolean
+}>()
+
+const emit = defineEmits<{ 'update:modelValue': [MergeClassRules] }>()
+
+const { t, n } = useI18n()
+const trackRecords = useMergeTrackRecordsStore()
+
+// Load the rollups once when the editor mounts. ONE request returns every class (a single SQL
+// aggregate server-side), so this never fans out per class.
+onMounted(() => {
+  if (!trackRecords.loaded && !trackRecords.loading) void trackRecords.load()
+})
+
+// Per-class + per-rule labels. Exhaustive Records keyed off the unions (a missing member fails the
+// typecheck) with LITERAL catalog keys so the typed-message-keys check sees them.
+const CLASS_LABEL_KEYS: Record<(typeof RULEABLE_CHANGE_CLASSES)[number], string> = {
+  docs: 'merge.changeClass.docs',
+  test: 'merge.changeClass.test',
+  dependency: 'merge.changeClass.dependency',
+  config: 'merge.changeClass.config',
+  source: 'merge.changeClass.source',
+  schema: 'merge.changeClass.schema',
+}
+const RULE_LABEL_KEYS: Record<MergeClassRule, string> = {
+  thresholds: 'settings.riskPolicy.classRules.rule.thresholds',
+  always: 'settings.riskPolicy.classRules.rule.always',
+  never: 'settings.riskPolicy.classRules.rule.never',
+}
+
+const RULE_OPTIONS = computed<{ value: MergeClassRule; label: string }[]>(() => [
+  { value: 'thresholds', label: t(RULE_LABEL_KEYS.thresholds) },
+  { value: 'always', label: t(RULE_LABEL_KEYS.always) },
+  { value: 'never', label: t(RULE_LABEL_KEYS.never) },
+])
+
+/** One row: the class, its current rule, and the evidence behind it. */
+const rows = computed(() =>
+  RULEABLE_CHANGE_CLASSES.map((changeClass) => {
+    const rollup = trackRecords.byClass[changeClass]
+    const auto = autoMergeShare(rollup)
+    const frictionless = frictionlessShare(rollup)
+    return {
+      changeClass,
+      label: t(CLASS_LABEL_KEYS[changeClass]),
+      rule: props.modelValue[changeClass] ?? ('thresholds' as MergeClassRule),
+      merged: rollup.merged,
+      // Null until something has landed / been tagged, so a fresh workspace shows "no data yet"
+      // rather than a misleading 0%.
+      autoShare: auto,
+      frictionlessShare: frictionless,
+    }
+  }),
+)
+
+/** Set (or clear) a class's rule. `thresholds` is stored as an OMISSION — it IS the default. */
+function setRule(changeClass: (typeof RULEABLE_CHANGE_CLASSES)[number], rule: MergeClassRule) {
+  const next: MergeClassRules = { ...props.modelValue }
+  if (rule === 'thresholds') delete next[changeClass]
+  else next[changeClass] = rule
+  emit('update:modelValue', next)
+}
+</script>
+
+<template>
+  <div data-testid="merge-class-rules" class="space-y-2">
+    <div>
+      <span class="block text-[10px] uppercase tracking-wide text-slate-500">
+        {{ t('settings.riskPolicy.classRules.heading') }}
+      </span>
+      <p class="mt-0.5 text-[11px] leading-snug text-slate-500">
+        {{ t('settings.riskPolicy.classRules.help') }}
+      </p>
+      <p v-if="!autoMergeEnabled" class="mt-1 text-[11px] leading-snug text-amber-400/90">
+        {{ t('settings.riskPolicy.classRules.autoMergeOffWarning') }}
+      </p>
+    </div>
+
+    <div
+      v-for="row in rows"
+      :key="row.changeClass"
+      class="flex flex-wrap items-center gap-2 rounded-md border border-slate-700/50 bg-slate-900/30 px-2 py-1.5"
+      :data-testid="`merge-class-row-${row.changeClass}`"
+    >
+      <span class="min-w-[7rem] text-xs text-slate-300">{{ row.label }}</span>
+      <USelect
+        :model-value="row.rule"
+        :items="RULE_OPTIONS"
+        value-key="value"
+        size="sm"
+        class="w-44"
+        :disabled="disabled"
+        :data-testid="`merge-class-rule-${row.changeClass}`"
+        @update:model-value="setRule(row.changeClass, $event as MergeClassRule)"
+      />
+      <span
+        class="text-[11px] text-slate-500"
+        :data-testid="`merge-class-record-${row.changeClass}`"
+      >
+        <template v-if="row.merged === 0">
+          {{ t('settings.riskPolicy.classRules.noData') }}
+        </template>
+        <template v-else>
+          {{
+            t('settings.riskPolicy.classRules.record', {
+              merged: row.merged,
+              autoShare: n(row.autoShare ?? 0, 'percent'),
+            })
+          }}
+          <template v-if="row.frictionlessShare !== null">
+            &middot;
+            {{
+              t('settings.riskPolicy.classRules.frictionless', {
+                share: n(row.frictionlessShare, 'percent'),
+              })
+            }}
+          </template>
+        </template>
+      </span>
+    </div>
+  </div>
+</template>

package/app/components/settings/RiskPolicyPanel.vue

@@ -5,7 +5,7 @@
 // task inspector's "Merge policy" dropdown selects from. Exactly one preset is the
 // default; it cannot be deleted or un-defaulted (the backend enforces this too).
 import { computed, reactive, ref, watch } from 'vue'
-import type { RiskPolicy, RequirementConcernLevel } from '~/types/merge'
+import type { MergeClassRules, RiskPolicy, RequirementConcernLevel } from '~/types/merge'
 import type { StepGating } from '@cat-factory/contracts'
 
 const { t } = useI18n()
@@ -43,6 +43,9 @@ interface Draft {
   maxRequirementIterations: number
   maxRequirementConcernAllowed: RequirementConcernLevel
   autoMergeEnabled: boolean
+  // Per-change-class auto-merge rules. An OMITTED class means "use the score ceilings above",
+  // so `{}` is the identity — the editor stores `thresholds` as an omission for that reason.
+  classRules: MergeClassRules
   // Implementation-fork decision gating (edited 0..100, stored 0..1); disabled ⇒ off in `auto`.
   forkEnabled: boolean
   forkMinComplexity: number
@@ -79,6 +82,7 @@ function toDraft(p: RiskPolicy): Draft {
     maxRequirementIterations: p.maxRequirementIterations,
     maxRequirementConcernAllowed: p.maxRequirementConcernAllowed,
     autoMergeEnabled: p.autoMergeEnabled,
+    classRules: { ...p.classRules },
     forkEnabled: p.forkDecision?.enabled ?? false,
     forkMinComplexity: Math.round((p.forkDecision?.minComplexity ?? 0.5) * 100),
     forkMinRisk: Math.round((p.forkDecision?.minRisk ?? 0.4) * 100),
@@ -121,6 +125,7 @@ async function save(p: RiskPolicy) {
       maxRequirementIterations: d.maxRequirementIterations,
       maxRequirementConcernAllowed: d.maxRequirementConcernAllowed,
       autoMergeEnabled: d.autoMergeEnabled,
+      classRules: d.classRules,
       forkDecision: forkGating(d),
     })
     toast.add({
@@ -176,6 +181,7 @@ const draft = reactive<Draft>({
   maxRequirementIterations: 6,
   maxRequirementConcernAllowed: 'none',
   autoMergeEnabled: true,
+  classRules: {},
   forkEnabled: false,
   forkMinComplexity: 50,
   forkMinRisk: 40,
@@ -196,10 +202,12 @@ async function create() {
       maxRequirementIterations: draft.maxRequirementIterations,
       maxRequirementConcernAllowed: draft.maxRequirementConcernAllowed,
       autoMergeEnabled: draft.autoMergeEnabled,
+      classRules: draft.classRules,
       forkDecision: forkGating(draft),
     })
     draft.name = ''
     draft.autoMergeEnabled = true
+    draft.classRules = {}
     toast.add({
       title: t('settings.riskPolicy.toast.created'),
       icon: 'i-lucide-check',
@@ -341,6 +349,16 @@ async function create() {
         </label>
       </div>
 
+      <!-- Per-change-class auto-merge rules, each shown beside that class's accumulated track
+           record — the number that justifies widening the rule. -->
+      <div class="mt-3 rounded-md border border-slate-800 bg-slate-900/40 p-3">
+        <MergeClassRulesEditor
+          v-model="drafts[p.id]!.classRules"
+          :auto-merge-enabled="drafts[p.id]!.autoMergeEnabled"
+          :disabled="busy === p.id"
+        />
+      </div>
+
       <!-- Implementation-fork decision gate: propose materially different approaches before the
            Coder writes code (in `auto` tri-state, gated on the task estimate). -->
       <div class="mt-3 rounded-md border border-slate-800 bg-slate-900/40 p-3">

package/app/components/slack/SlackPanel.vue

@@ -32,6 +32,7 @@ const back = useIntegrationBack(open)
 const ROUTABLE = computed<{ type: NotificationType; label: string }[]>(() => [
   { type: 'merge_review', label: t('slack.routable.merge_review') },
   { type: 'pipeline_complete', label: t('slack.routable.pipeline_complete') },
+  { type: 'merge_tag_request', label: t('slack.routable.merge_tag_request') },
   { type: 'ci_failed', label: t('slack.routable.ci_failed') },
   { type: 'test_failed', label: t('slack.routable.test_failed') },
   { type: 'requirement_review', label: t('slack.routable.requirement_review') },
@@ -54,6 +55,7 @@ const ROLE_OPTIONS = computed<{ label: string; value: SlackMemberRole }[]>(() =>
 const routes = reactive<Record<NotificationType, SlackRoute>>({
   merge_review: { enabled: false, channel: '' },
   pipeline_complete: { enabled: false, channel: '' },
+  merge_tag_request: { enabled: false, channel: '' },
   ci_failed: { enabled: false, channel: '' },
   test_failed: { enabled: false, channel: '' },
   requirement_review: { enabled: false, channel: '' },

package/app/composables/api/execution.ts

@@ -17,6 +17,7 @@ import {
 } from '@cat-factory/contracts'
 import type { RequestStepChangesInput } from '@cat-factory/contracts'
 import type { IterationCapChoice } from '~/types/execution'
+import type { ReviewEffort } from '~/types/merge'
 import type { ApiContext } from './context'
 
 /** Run lifecycle (start/cancel/decisions/approvals/restart) + LLM metrics + spend. */
@@ -38,8 +39,14 @@ export function executionApi({ send, sendWith, ws, pwHeaders }: ApiContext) {
     cancelExecution: (workspaceId: string, blockId: string) =>
       send(cancelExecutionContract, { pathPrefix: ws(workspaceId), pathParams: { blockId } }),
 
-    mergeBlock: (workspaceId: string, blockId: string) =>
-      send(mergeBlockContract, { pathPrefix: ws(workspaceId), pathParams: { blockId } }),
+    // `reviewEffort` records the reviewer-effort tag onto the block's merge track record in the
+    // same request as the merge (see the notification `act` counterpart). Always optional.
+    mergeBlock: (workspaceId: string, blockId: string, reviewEffort?: ReviewEffort | null) =>
+      send(mergeBlockContract, {
+        pathPrefix: ws(workspaceId),
+        pathParams: { blockId },
+        body: reviewEffort === undefined ? {} : { reviewEffort },
+      }),
 
     resolveDecision: (
       workspaceId: string,