@cat-factory/app 0.150.1 → 0.151.0

package/app/components/board/AddTaskModal.vue

@@ -28,6 +28,7 @@ import ContextDocumentPicker from '~/components/documents/ContextDocumentPicker.
 import ContextIssuePicker from '~/components/tasks/ContextIssuePicker.vue'
 import FragmentSelector from '~/components/fragments/FragmentSelector.vue'
 import { riskPolicyOptionLabel, riskPolicySummary } from '~/utils/riskPolicy'
+import { parseConflict } from '~/composables/usePipelineErrorToast'
 import { pipelineAllowedForManualStart } from '~/utils/pipeline'
 
 const ui = useUiStore()
@@ -678,8 +679,7 @@ const canAdd = computed(() => {
 })
 
 async function add() {
-  const containerId = ui.addTaskContainerId
-  if (!containerId || !canAdd.value) return
+  if (!canAdd.value) return
   // Recurring tasks are created via a schedule on the service frame — hand off to the
   // existing recurring-pipeline modal (which carries the cadence + prompt).
   if (isRecurring.value) {
@@ -689,6 +689,17 @@ async function add() {
     ui.openAddRecurring(frameId)
     return
   }
+  await submitCreate(false)
+}
+
+/**
+ * Create the task, optionally acknowledging review-debt friction. A `review_debt_*` 409 opens the
+ * friction dialog instead of a bare error toast: the soft `warn` tier's dialog can retry via
+ * `submitCreate(true)` (the `onConfirm`), while a hard `blocked` tier only offers "Go review".
+ */
+async function submitCreate(acknowledgeReviewDebt: boolean) {
+  const containerId = ui.addTaskContainerId
+  if (!containerId) return
   saving.value = true
   try {
     const typeFields = buildTypeFields()
@@ -718,6 +729,7 @@ async function add() {
       // re-seeded from the service. The task owns its fragments from here.
       fragmentIds: [...fragmentIds.value],
       ...(technical.value ? { technical: true } : {}),
+      ...(acknowledgeReviewDebt ? { acknowledgeReviewDebt: true } : {}),
     })
     if (block) {
       // Surface the SPECIFIC cause of any attachment that couldn't be linked (a GitHub
@@ -725,8 +737,14 @@ async function add() {
       // one-click "Copy details" for a bug report.
       presentLinkFailures(await linkPending(block.id, pendingContext.value), block.id)
     }
+    ui.closeReviewFriction()
     ui.closeAddTask()
   } catch (e) {
+    const conflict = parseConflict(e)
+    if (conflict?.reason === 'review_debt_warn' || conflict?.reason === 'review_debt_blocked') {
+      openReviewFrictionDialog(conflict)
+      return
+    }
     toast.add({
       title: t('board.addTask.addFailedTitle'),
       description: e instanceof Error ? e.message : String(e),
@@ -737,6 +755,29 @@ async function add() {
     saving.value = false
   }
 }
+
+/** Turn a parsed review-debt friction 409 into the dialog context (see ReviewFrictionDialog.vue). */
+function openReviewFrictionDialog(conflict: NonNullable<ReturnType<typeof parseConflict>>) {
+  const details = conflict.details
+  const rawDebt = Array.isArray(details.debt) ? details.debt : []
+  const debt = rawDebt.map((d) => {
+    const row = (d ?? {}) as { blockId?: unknown; title?: unknown; waitingMinutes?: unknown }
+    return {
+      blockId: typeof row.blockId === 'string' ? row.blockId : '',
+      title: typeof row.title === 'string' ? row.title : null,
+      waitingMinutes: typeof row.waitingMinutes === 'number' ? row.waitingMinutes : 0,
+    }
+  })
+  const isWarn = conflict.reason === 'review_debt_warn'
+  ui.openReviewFriction({
+    kind: isWarn ? 'warn' : 'blocked',
+    reason:
+      details.friction === 'count' || details.friction === 'stuck' ? details.friction : undefined,
+    threshold: typeof details.threshold === 'number' ? details.threshold : null,
+    debt,
+    onConfirm: isWarn ? () => void submitCreate(true) : null,
+  })
+}
 </script>
 
 <template>

package/app/components/board/ReviewDebtBadge.vue

@@ -0,0 +1,26 @@
+<script setup lang="ts">
+// A small pre-warn badge shown next to an "Add task" affordance when the workspace's opt-in
+// review-debt friction is at (or past) its threshold, so the friction dialog isn't a surprise.
+// Hidden entirely when friction is off or the queue is under the warn threshold. The server
+// remains the authority — this is a hint. See backend/docs/review-debt-friction.md.
+import { computed } from 'vue'
+import { useReviewDebt } from '~/composables/useReviewDebt'
+
+const { active, debtCount, blocked } = useReviewDebt()
+const { t } = useI18n()
+
+const color = computed(() => (blocked.value ? 'error' : 'warning'))
+</script>
+
+<template>
+  <UBadge
+    v-if="active"
+    :color="color"
+    variant="subtle"
+    size="sm"
+    icon="i-lucide-clock"
+    :title="t('errors.reviewFriction.badge', { count: debtCount })"
+  >
+    {{ debtCount }}
+  </UBadge>
+</template>

package/app/components/board/ReviewFrictionDialog.vue

@@ -0,0 +1,118 @@
+<script setup lang="ts">
+// Opt-in review-debt friction dialog. Shown when a task-create request is refused by the friction
+// gate (a `review_debt_warn` / `review_debt_blocked` 409). It lists exactly which tasks are waiting
+// on human review (worst first), each deep-linking to its block so "go review instead" is one
+// click. The soft `warn` tier offers a secondary "Create anyway" (retries with the acknowledge
+// flag); the hard `blocked` tier does not. Driven by `ui.reviewFrictionContext`, mounted in
+// pages/index.vue. See backend/docs/review-debt-friction.md.
+import { computed } from 'vue'
+
+const { t } = useI18n()
+const ui = useUiStore()
+
+const ctx = computed(() => ui.reviewFrictionContext)
+
+const open = computed({
+  get: () => ctx.value !== null,
+  set: (v: boolean) => {
+    if (!v) ui.closeReviewFriction()
+  },
+})
+
+const title = computed(() =>
+  ctx.value?.kind === 'blocked'
+    ? t('errors.reviewFriction.blockedTitle')
+    : t('errors.reviewFriction.warnTitle'),
+)
+
+const body = computed(() => {
+  const c = ctx.value
+  if (!c) return ''
+  if (c.kind === 'warn') return t('errors.reviewFriction.warnBody', { count: c.debt.length })
+  if (c.reason === 'stuck')
+    return t('errors.reviewFriction.blockedStuckBody', { minutes: c.threshold ?? 0 })
+  return t('errors.reviewFriction.blockedCountBody', {
+    count: c.debt.length,
+    threshold: c.threshold ?? 0,
+  })
+})
+
+/** Deep-link to a waiting task's block and dismiss the whole friction flow. */
+function goToBlock(blockId: string) {
+  if (blockId) ui.select(blockId)
+  ui.closeReviewFriction()
+  ui.closeAddTask()
+}
+
+function goReview() {
+  const first = ctx.value?.debt[0]
+  if (first) goToBlock(first.blockId)
+  else {
+    ui.closeReviewFriction()
+    ui.closeAddTask()
+  }
+}
+
+function createAnyway() {
+  ctx.value?.onConfirm?.()
+}
+</script>
+
+<template>
+  <UModal v-model:open="open" :title="title" :ui="{ content: 'max-w-xl' }">
+    <template #body>
+      <div v-if="ctx" class="space-y-5">
+        <p class="text-sm text-slate-300">{{ body }}</p>
+
+        <div class="rounded-lg border border-slate-700 bg-slate-900/50 p-2">
+          <p class="mb-1.5 px-1 text-[11px] font-semibold uppercase tracking-wide text-slate-500">
+            {{ t('errors.reviewFriction.waitingHeading') }}
+          </p>
+          <ul class="space-y-1">
+            <li v-for="item in ctx.debt" :key="item.blockId">
+              <button
+                type="button"
+                class="flex w-full items-center justify-between gap-3 rounded-md px-2 py-1.5 text-left text-sm hover:bg-slate-800/60"
+                @click="goToBlock(item.blockId)"
+              >
+                <span class="truncate text-slate-200">
+                  {{ item.title || t('errors.reviewFriction.untitled') }}
+                </span>
+                <span class="shrink-0 text-[12px] text-slate-500">
+                  {{ t('errors.reviewFriction.waiting', { minutes: item.waitingMinutes }) }}
+                </span>
+              </button>
+            </li>
+          </ul>
+        </div>
+
+        <div class="flex flex-wrap justify-end gap-2">
+          <UButton
+            color="neutral"
+            variant="ghost"
+            size="sm"
+            @click="
+              () => {
+                open = false
+              }
+            "
+          >
+            {{ t('errors.reviewFriction.close') }}
+          </UButton>
+          <UButton
+            v-if="ctx.onConfirm"
+            color="neutral"
+            variant="subtle"
+            size="sm"
+            @click="createAnyway"
+          >
+            {{ t('errors.reviewFriction.createAnyway') }}
+          </UButton>
+          <UButton color="primary" size="sm" icon="i-lucide-list-checks" @click="goReview">
+            {{ t('errors.reviewFriction.goReview') }}
+          </UButton>
+        </div>
+      </div>
+    </template>
+  </UModal>
+</template>

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

@@ -2,6 +2,7 @@
 import type { Block } from '~/types/domain'
 import { STATUS_META } from '~/utils/catalog'
 import InspectorSection from '~/components/panels/inspector/InspectorSection.vue'
+import ReviewDebtBadge from '~/components/board/ReviewDebtBadge.vue'
 
 const props = defineProps<{ block: Block }>()
 
@@ -61,9 +62,12 @@ function addTask() {
               : t('inspector.container.tasks', { count: tasks.length })
           }}
         </span>
-        <UButton size="xs" variant="soft" color="primary" icon="i-lucide-plus" @click="addTask">
-          {{ t('inspector.container.addTask') }}
-        </UButton>
+        <div class="flex items-center gap-1.5">
+          <ReviewDebtBadge />
+          <UButton size="xs" variant="soft" color="primary" icon="i-lucide-plus" @click="addTask">
+            {{ t('inspector.container.addTask') }}
+          </UButton>
+        </div>
       </div>
       <ul v-if="tasks.length" class="space-y-1">
         <li

package/app/components/settings/WorkspaceSettingsPanel.vue

@@ -8,7 +8,7 @@
 // The latter three are body-only section components rendered in tabs here (no longer
 // standalone modals).
 import { reactive, ref, watch } from 'vue'
-import type { TaskLimitMode } from '~/types/domain'
+import type { ReviewFrictionMode, TaskLimitMode } from '~/types/domain'
 import RiskPolicyPanel from '~/components/settings/RiskPolicyPanel.vue'
 import IssueTrackerPanel from '~/components/settings/IssueTrackerPanel.vue'
 import ServiceFragmentDefaultsPanel from '~/components/settings/ServiceFragmentDefaultsPanel.vue'
@@ -129,6 +129,12 @@ const MODES = computed<{ value: TaskLimitMode; label: string }[]>(() => [
   { value: 'per_type', label: t('settings.workspaceSettings.taskLimit.modes.per_type') },
 ])
 
+const REVIEW_FRICTION_MODES = computed<{ value: ReviewFrictionMode; label: string }[]>(() => [
+  { value: 'off', label: t('settings.workspaceSettings.reviewFriction.modes.off') },
+  { value: 'warn', label: t('settings.workspaceSettings.reviewFriction.modes.warn') },
+  { value: 'enforce', label: t('settings.workspaceSettings.reviewFriction.modes.enforce') },
+])
+
 /** The localized "Max {type} tasks" label for a per-type running-task limit input. */
 function maxTaskTypeLabel(type: LimitTaskType): string {
   const key = TASK_TYPE_KEYS[type]
@@ -145,6 +151,12 @@ const draft = reactive({
   storeAgentContext: true,
   artifactRetentionDays: 14,
   kaizenEnabled: true,
+  reviewFrictionMode: 'off' as ReviewFrictionMode,
+  reviewFrictionWarnCount: 3,
+  reviewFrictionBlockCountEnabled: false,
+  reviewFrictionBlockCount: 10 as number,
+  reviewFrictionBlockStuckEnabled: false,
+  reviewFrictionBlockStuckMinutes: 1440 as number,
 })
 
 function hydrate() {
@@ -157,6 +169,14 @@ function hydrate() {
   draft.storeAgentContext = s.storeAgentContext
   draft.artifactRetentionDays = s.artifactRetentionDays
   draft.kaizenEnabled = s.kaizenEnabled
+  draft.reviewFrictionMode = s.reviewFrictionMode
+  draft.reviewFrictionWarnCount = s.reviewFrictionWarnCount
+  // The hard-block knobs are nullable (null ⇒ that trigger is off); a per-trigger checkbox is
+  // enabled from whether a value is stored, defaulting the input to a sensible starting number.
+  draft.reviewFrictionBlockCountEnabled = s.reviewFrictionBlockCount != null
+  draft.reviewFrictionBlockCount = s.reviewFrictionBlockCount ?? 10
+  draft.reviewFrictionBlockStuckEnabled = s.reviewFrictionBlockStuckMinutes != null
+  draft.reviewFrictionBlockStuckMinutes = s.reviewFrictionBlockStuckMinutes ?? 1440
 }
 
 // `store.settings` is always replaced wholesale (store hydrate/update reassign the ref),
@@ -166,6 +186,25 @@ watch(() => store.settings, hydrate, { immediate: true })
 const saving = ref(false)
 
 async function save() {
+  // The hard-block triggers only apply in `enforce` mode; a disabled trigger sends null.
+  const blockCount =
+    draft.reviewFrictionMode === 'enforce' && draft.reviewFrictionBlockCountEnabled
+      ? draft.reviewFrictionBlockCount
+      : null
+  const blockStuckMinutes =
+    draft.reviewFrictionMode === 'enforce' && draft.reviewFrictionBlockStuckEnabled
+      ? draft.reviewFrictionBlockStuckMinutes
+      : null
+  // Mirror the backend's enforce-mode validation client-side so the user gets an immediate,
+  // localized message instead of the raw 422 (enforce needs at least one hard trigger).
+  if (draft.reviewFrictionMode === 'enforce' && blockCount == null && blockStuckMinutes == null) {
+    toast.add({
+      title: t('settings.workspaceSettings.reviewFriction.needsTrigger'),
+      icon: 'i-lucide-triangle-alert',
+      color: 'warning',
+    })
+    return
+  }
   saving.value = true
   try {
     await store.update({
@@ -185,6 +224,10 @@ async function save() {
       storeAgentContext: draft.storeAgentContext,
       artifactRetentionDays: draft.artifactRetentionDays,
       kaizenEnabled: draft.kaizenEnabled,
+      reviewFrictionMode: draft.reviewFrictionMode,
+      reviewFrictionWarnCount: draft.reviewFrictionWarnCount,
+      reviewFrictionBlockCount: blockCount,
+      reviewFrictionBlockStuckMinutes: blockStuckMinutes,
     })
     toast.add({
       title: t('settings.workspaceSettings.toast.saved'),
@@ -288,6 +331,80 @@ async function save() {
               </div>
             </section>
 
+            <!-- Review-debt friction on task creation -->
+            <section class="space-y-2">
+              <h3 class="text-sm font-semibold text-slate-200">
+                {{ t('settings.workspaceSettings.reviewFriction.heading') }}
+              </h3>
+              <p class="text-[11px] text-slate-400">
+                {{ t('settings.workspaceSettings.reviewFriction.body') }}
+              </p>
+              <label class="block w-64">
+                <span class="mb-1 block text-[10px] uppercase tracking-wide text-slate-500">{{
+                  t('settings.workspaceSettings.reviewFriction.mode')
+                }}</span>
+                <USelect
+                  v-model="draft.reviewFrictionMode"
+                  :items="REVIEW_FRICTION_MODES"
+                  value-key="value"
+                  size="sm"
+                  class="w-full"
+                />
+              </label>
+
+              <label v-if="draft.reviewFrictionMode !== 'off'" class="block w-48">
+                <span class="mb-1 block text-[10px] uppercase tracking-wide text-slate-500">
+                  {{ t('settings.workspaceSettings.reviewFriction.warnCount') }}
+                </span>
+                <UInput
+                  v-model.number="draft.reviewFrictionWarnCount"
+                  type="number"
+                  :min="1"
+                  size="sm"
+                />
+              </label>
+
+              <div v-if="draft.reviewFrictionMode === 'enforce'" class="space-y-2">
+                <p class="text-[11px] text-slate-400">
+                  {{ t('settings.workspaceSettings.reviewFriction.enforceHint') }}
+                </p>
+                <label class="flex items-center gap-2">
+                  <USwitch v-model="draft.reviewFrictionBlockCountEnabled" size="sm" />
+                  <span class="text-[13px] text-slate-300">{{
+                    t('settings.workspaceSettings.reviewFriction.blockCountToggle')
+                  }}</span>
+                </label>
+                <label v-if="draft.reviewFrictionBlockCountEnabled" class="block w-48">
+                  <span class="mb-1 block text-[10px] uppercase tracking-wide text-slate-500">
+                    {{ t('settings.workspaceSettings.reviewFriction.blockCount') }}
+                  </span>
+                  <UInput
+                    v-model.number="draft.reviewFrictionBlockCount"
+                    type="number"
+                    :min="1"
+                    size="sm"
+                  />
+                </label>
+                <label class="flex items-center gap-2">
+                  <USwitch v-model="draft.reviewFrictionBlockStuckEnabled" size="sm" />
+                  <span class="text-[13px] text-slate-300">{{
+                    t('settings.workspaceSettings.reviewFriction.blockStuckToggle')
+                  }}</span>
+                </label>
+                <label v-if="draft.reviewFrictionBlockStuckEnabled" class="block w-48">
+                  <span class="mb-1 block text-[10px] uppercase tracking-wide text-slate-500">
+                    {{ t('settings.workspaceSettings.reviewFriction.blockStuckMinutes') }}
+                  </span>
+                  <UInput
+                    v-model.number="draft.reviewFrictionBlockStuckMinutes"
+                    type="number"
+                    :min="1"
+                    size="sm"
+                  />
+                </label>
+              </div>
+            </section>
+
             <!-- Agent observability -->
             <section class="space-y-2">
               <h3 class="text-sm font-semibold text-slate-200">

package/app/composables/api/board.ts

@@ -54,6 +54,7 @@ export function boardApi({ send, ws }: ApiContext) {
         pipelineId?: string
         agentConfig?: Record<string, string>
         technical?: boolean
+        acknowledgeReviewDebt?: boolean
       },
     ) => send(addTaskContract, { pathPrefix: ws(workspaceId), pathParams: { blockId }, body }),
 

package/app/composables/usePipelineErrorToast.ts

@@ -166,6 +166,18 @@ const CONFLICT_INFO: Record<Exclude<ConflictReason, BespokeConflictReason>, Conf
       run: (ui) => ui.openGitHub(),
     },
   },
+  // Opt-in review-debt friction. In the normal task-create flow AddTaskModal intercepts these
+  // 409s and opens the friction dialog (which can retry with an acknowledgement), so these entries
+  // are the last-resort toast fallback for any OTHER caller — a generic, param-free title +
+  // description reusing the dialog's own `errors.reviewFriction.*` namespace.
+  review_debt_warn: {
+    titleKey: 'errors.reviewFriction.warnTitle',
+    descriptionKey: 'errors.reviewFriction.warnToast',
+  },
+  review_debt_blocked: {
+    titleKey: 'errors.reviewFriction.blockedTitle',
+    descriptionKey: 'errors.reviewFriction.blockedToast',
+  },
 }
 
 /**

package/app/composables/useReviewDebt.ts

@@ -0,0 +1,23 @@
+import { computed } from 'vue'
+import { assessReviewFriction } from '@cat-factory/contracts'
+import { useNotificationsStore } from '~/stores/notifications'
+import { useWorkspaceSettingsStore } from '~/stores/workspaceSettings'
+
+/**
+ * The client-side review-debt verdict, computed from the SAME pure `assessReviewFriction` the
+ * backend enforces with, over the workspace snapshot's open notifications + settings. Lets the
+ * add-task affordances pre-warn (a debt badge) BEFORE a create is attempted, so the friction
+ * dialog is rarely a surprise. The server stays the authority — this is a hint only. See
+ * backend/docs/review-debt-friction.md.
+ */
+export function useReviewDebt() {
+  const notifications = useNotificationsStore()
+  const settings = useWorkspaceSettingsStore()
+  const verdict = computed(() =>
+    assessReviewFriction(notifications.open, settings.settings, Date.now()),
+  )
+  const active = computed(() => verdict.value.kind !== 'ok')
+  const debtCount = computed(() => (verdict.value.kind === 'ok' ? 0 : verdict.value.debt.length))
+  const blocked = computed(() => verdict.value.kind === 'block')
+  return { verdict, active, debtCount, blocked }
+}

package/app/pages/index.vue

@@ -17,6 +17,7 @@ import DecisionModal from '~/components/panels/DecisionModal.vue'
 import AgentStepDetail from '~/components/panels/AgentStepDetail.vue'
 import StepResultViewHost from '~/components/panels/StepResultViewHost.vue'
 import AddTaskModal from '~/components/board/AddTaskModal.vue'
+import ReviewFrictionDialog from '~/components/board/ReviewFrictionDialog.vue'
 import CreateInitiativeModal from '~/components/board/CreateInitiativeModal.vue'
 import GitHubOnboarding from '~/components/github/GitHubOnboarding.vue'
 import CommandBar from '~/components/layout/CommandBar.vue'
@@ -377,6 +378,7 @@ watch(
       <AgentStepDetail />
       <StepResultViewHost />
       <AddTaskModal />
+      <ReviewFrictionDialog v-if="ui.reviewFrictionContext" />
       <CreateInitiativeModal />
       <CommandBar />
       <PersonalCredentialModal />

package/app/stores/board/mutations.ts

@@ -73,6 +73,9 @@ export function createBoardMutations(ctx: BoardWriteContext) {
       agentConfig?: Record<string, string>
       fragmentIds?: string[]
       technical?: boolean
+      // Opt-in review-debt friction: set on the retry after the human confirms the friction
+      // dialog, so a soft `review_debt_warn` 409 is tunnelled through (never a hard block).
+      acknowledgeReviewDebt?: boolean
     },
   ): Promise<Block | undefined> {
     if (!getBlock(containerId)) return
@@ -90,6 +93,7 @@ export function createBoardMutations(ctx: BoardWriteContext) {
       // when a caller doesn't manage fragments at all (then the backend seeds from the service).
       ...(options?.fragmentIds !== undefined ? { fragmentIds: options.fragmentIds } : {}),
       ...(options?.technical ? { technical: true } : {}),
+      ...(options?.acknowledgeReviewDebt ? { acknowledgeReviewDebt: true } : {}),
     })
     upsert(block)
     return block

package/app/stores/ui/modals.ts

@@ -25,6 +25,29 @@ export interface K3sSetupPrefill {
   insecureSkipTlsVerify?: boolean
 }
 
+/** One task waiting on human review, as carried on a review-debt friction 409's details. */
+export interface ReviewDebtRow {
+  blockId: string
+  /** The task's title, joined in server-side; null when it couldn't be resolved. */
+  title: string | null
+  /** How long the task has been waiting on review, in minutes. */
+  waitingMinutes: number
+}
+
+/** The context a review-debt friction dialog renders + acts on (from the parsed 409). */
+export interface ReviewFrictionModalContext {
+  /** `warn` = soft friction (the human may proceed); `blocked` = hard block (they may not). */
+  kind: 'warn' | 'blocked'
+  /** Which hard trigger fired (`count` / `stuck`), for the blocked-tier message. */
+  reason?: 'count' | 'stuck'
+  /** The count / stuck-minutes threshold that fired, for the message. */
+  threshold?: number | null
+  /** The waiting tasks, worst-first, each deep-linkable to its block. */
+  debt: ReviewDebtRow[]
+  /** Retry the create with `acknowledgeReviewDebt` — present only for the soft `warn` tier. */
+  onConfirm: (() => void) | null
+}
+
 /** Clears both hub came-from markers; injected into the slices whose `open*` handlers reset them. */
 type ResetHubReturn = () => void
 
@@ -167,6 +190,14 @@ function createDocumentTaskModals(resetHubReturn: ResetHubReturn) {
   // linked context). The user still confirms pipeline / preset before adding.
   const addTaskPrefill = ref<AddTaskPrefill | null>(null)
 
+  // Review-debt friction dialog: opened when a task-create request is refused by the opt-in
+  // friction gate (`review_debt_warn` / `review_debt_blocked` 409). Carries the parsed conflict
+  // details the backend supplied (the waiting tasks + the trigger) so the dialog can list exactly
+  // what is in review, and — for the soft `warn` tier — an `onConfirm` the "Create anyway" button
+  // runs to retry the create with `acknowledgeReviewDebt`. Null when closed. See
+  // backend/docs/review-debt-friction.md.
+  const reviewFrictionContext = ref<ReviewFrictionModalContext | null>(null)
+
   // Add-recurring-pipeline modal: the service frame a new recurring pipeline is
   // being added to, or null when closed (mirrors the add-task flow — a button on
   // the frame opens it, scoped to that frame).
@@ -232,6 +263,12 @@ function createDocumentTaskModals(resetHubReturn: ResetHubReturn) {
     addTaskContainerId.value = null
     addTaskPrefill.value = null
   }
+  function openReviewFriction(ctx: ReviewFrictionModalContext) {
+    reviewFrictionContext.value = ctx
+  }
+  function closeReviewFriction() {
+    reviewFrictionContext.value = null
+  }
   function openAddRecurring(frameId: string) {
     addRecurringFrameId.value = frameId
   }
@@ -254,6 +291,7 @@ function createDocumentTaskModals(resetHubReturn: ResetHubReturn) {
     taskImport,
     addTaskContainerId,
     addTaskPrefill,
+    reviewFrictionContext,
     addRecurringFrameId,
     createInitiativeFrameId,
     openDocumentConnect,
@@ -270,6 +308,8 @@ function createDocumentTaskModals(resetHubReturn: ResetHubReturn) {
     closeTaskImport,
     openAddTask,
     closeAddTask,
+    openReviewFriction,
+    closeReviewFriction,
     openAddRecurring,
     closeAddRecurring,
     openCreateInitiative,

package/app/stores/workspaceSettings.ts

@@ -13,6 +13,10 @@ const DEFAULTS: WorkspaceSettings = {
   artifactRetentionDays: 14,
   kaizenEnabled: true,
   delegateAgentsToRunnerPool: false,
+  reviewFrictionMode: 'off',
+  reviewFrictionWarnCount: 3,
+  reviewFrictionBlockCount: null,
+  reviewFrictionBlockStuckMinutes: null,
   spendCurrency: null,
   spendMonthlyLimit: null,
 }

package/app/types/domain.ts

@@ -76,6 +76,7 @@ export type {
   WorkspaceAccess,
   WorkspaceMember,
   TaskLimitMode,
+  ReviewFrictionMode,
   WorkspaceSettings,
   UpdateWorkspaceSettingsInput,
   UserSettings,

package/i18n/locales/de.json

@@ -738,6 +738,23 @@
         "review": "Review",
         "ralph": "Ralph-Schleife"
       },
+      "reviewFriction": {
+        "heading": "Review-Rückstau-Bremse",
+        "body": "Erschwert das Anlegen neuer Aufgaben, solange fertige Arbeit auf die menschliche Prüfung wartet. Standardmäßig aus. „Warnen“ fügt eine Bestätigung hinzu; „Erzwingen“ verweigert das Anlegen ab einem harten Limit ganz.",
+        "mode": "Modus",
+        "modes": {
+          "off": "Aus",
+          "warn": "Warnen (Bestätigung nötig)",
+          "enforce": "Erzwingen (harte Sperre)"
+        },
+        "warnCount": "Warnen ab (Aufgaben in Prüfung)",
+        "enforceHint": "„Erzwingen“ verweigert das Anlegen von Aufgaben. Aktiviere unten mindestens einen harten Auslöser.",
+        "blockCountToggle": "Sperren, wenn zu viele Aufgaben in Prüfung sind",
+        "blockCount": "Sperren ab (Aufgaben in Prüfung)",
+        "blockStuckToggle": "Sperren, wenn eine Aufgabe zu lange wartet",
+        "blockStuckMinutes": "Sperren nach (Minuten Wartezeit)",
+        "needsTrigger": "Der Modus „Erzwingen“ benötigt mindestens einen aktiven harten Auslöser (eine Anzahl oder eine Wartezeit)."
+      },
       "observability": {
         "heading": "Agenten-Observability",
         "body": "Speichere den vollständigen Kontext, der jedem Agenten bereitgestellt wird: die zusammengesetzten Prompts, die eingefügten Best-Practice-Fragmente und den vollständigen Inhalt der in seinen Container injizierten Dateien, sodass er später in der Observability-Ansicht inspiziert werden kann. Die Inhalte werden für denselben Zeitraum wie die LLM-Telemetrie pro Aufruf aufbewahrt. Deaktivieren, um die Speicherung zu stoppen (bestehende Snapshots werden durch die Aufbewahrung bereinigt).",
@@ -4060,6 +4077,22 @@
       "mergeFailed": "Zusammenführen fehlgeschlagen",
       "restartFailed": "Neustart fehlgeschlagen"
     },
+    "reviewFriction": {
+      "warnTitle": "Aufgaben warten auf Prüfung",
+      "blockedTitle": "Zu viele Aufgaben warten auf Prüfung",
+      "warnToast": "Einige Aufgaben warten auf die menschliche Prüfung. Prüfe sie, bevor du mehr Arbeit anlegst.",
+      "blockedToast": "Das Anlegen von Aufgaben ist gesperrt, bis der Prüf-Rückstau abgebaut ist.",
+      "warnBody": "{count} Aufgabe(n) warten auf die menschliche Prüfung. Prüfe sie, bevor du mehr Arbeit anlegst.",
+      "blockedCountBody": "Anlegen gesperrt: {count} Aufgabe(n) warten auf die menschliche Prüfung (Limit {threshold}). Baue zuerst den Prüf-Rückstau ab.",
+      "blockedStuckBody": "Anlegen gesperrt: Eine Aufgabe wartet seit über {minutes} Minute(n) auf die menschliche Prüfung. Baue zuerst den Prüf-Rückstau ab.",
+      "waitingHeading": "Warten auf Prüfung",
+      "waiting": "{minutes} Min. Wartezeit",
+      "untitled": "Aufgabe ohne Titel",
+      "close": "Schließen",
+      "createAnyway": "Trotzdem anlegen",
+      "goReview": "Zur Prüfung",
+      "badge": "{count} Aufgabe(n) warten auf Prüfung"
+    },
     "conflict": {
       "title": {
         "dependencies_unmet": "Durch Abhängigkeiten blockiert",

package/i18n/locales/en.json

@@ -493,6 +493,22 @@
       "mergeFailed": "Failed to merge",
       "restartFailed": "Failed to restart"
     },
+    "reviewFriction": {
+      "warnTitle": "Tasks waiting on review",
+      "blockedTitle": "Too many tasks waiting on review",
+      "warnToast": "Some tasks are waiting on human review. Consider reviewing them before creating more work.",
+      "blockedToast": "Task creation is blocked until the review queue is worked down.",
+      "warnBody": "{count} task(s) are waiting on human review. Consider reviewing them before creating more work.",
+      "blockedCountBody": "Task creation is blocked: {count} task(s) are waiting on human review (limit {threshold}). Work down the review queue first.",
+      "blockedStuckBody": "Task creation is blocked: a task has been waiting on human review for over {minutes} minute(s). Work down the review queue first.",
+      "waitingHeading": "Waiting on review",
+      "waiting": "{minutes} min waiting",
+      "untitled": "Untitled task",
+      "close": "Close",
+      "createAnyway": "Create anyway",
+      "goReview": "Go review",
+      "badge": "{count} task(s) waiting on review"
+    },
     "conflict": {
       "title": {
         "dependencies_unmet": "Blocked by dependencies",
@@ -2757,6 +2773,23 @@
         "review": "review",
         "ralph": "Ralph loop"
       },
+      "reviewFriction": {
+        "heading": "Review-debt friction",
+        "body": "Discourage authoring new tasks while finished work waits on human review. Off by default. Warn adds a confirm-to-proceed step; Enforce also refuses task creation outright past a hard limit.",
+        "mode": "Mode",
+        "modes": {
+          "off": "Off",
+          "warn": "Warn (confirm to proceed)",
+          "enforce": "Enforce (hard block)"
+        },
+        "warnCount": "Warn at (tasks in review)",
+        "enforceHint": "Enforce refuses task creation. Enable at least one hard trigger below.",
+        "blockCountToggle": "Block when too many tasks are in review",
+        "blockCount": "Block at (tasks in review)",
+        "blockStuckToggle": "Block when a task has waited too long",
+        "blockStuckMinutes": "Block after (minutes waiting)",
+        "needsTrigger": "Enforce mode needs at least one hard trigger enabled (a count or a wait time)."
+      },
       "observability": {
         "heading": "Agent observability",
         "body": "Store the complete context provided to each agent: the composed prompts, the best-practice fragments folded in, and the full content of the files injected into its container, so it can be inspected later in the observability view. The bodies are kept for the same window as the per-call LLM telemetry. Turn off to stop storing it (existing snapshots are pruned by retention).",

package/i18n/locales/es.json

@@ -457,6 +457,22 @@
       "mergeFailed": "No se pudo fusionar",
       "restartFailed": "No se pudo reiniciar"
     },
+    "reviewFriction": {
+      "warnTitle": "Tareas esperando revisión",
+      "blockedTitle": "Demasiadas tareas esperando revisión",
+      "warnToast": "Algunas tareas esperan revisión humana. Considera revisarlas antes de crear más trabajo.",
+      "blockedToast": "La creación de tareas está bloqueada hasta reducir la cola de revisión.",
+      "warnBody": "{count} tarea(s) esperan revisión humana. Considera revisarlas antes de crear más trabajo.",
+      "blockedCountBody": "Creación bloqueada: {count} tarea(s) esperan revisión humana (límite {threshold}). Reduce primero la cola de revisión.",
+      "blockedStuckBody": "Creación bloqueada: una tarea lleva más de {minutes} minuto(s) esperando revisión humana. Reduce primero la cola de revisión.",
+      "waitingHeading": "Esperando revisión",
+      "waiting": "{minutes} min esperando",
+      "untitled": "Tarea sin título",
+      "close": "Cerrar",
+      "createAnyway": "Crear de todos modos",
+      "goReview": "Ir a revisar",
+      "badge": "{count} tarea(s) esperando revisión"
+    },
     "conflict": {
       "title": {
         "dependencies_unmet": "Bloqueado por dependencias",
@@ -2569,6 +2585,23 @@
         "review": "revisión",
         "ralph": "Bucle Ralph"
       },
+      "reviewFriction": {
+        "heading": "Fricción por revisión pendiente",
+        "body": "Desalienta crear tareas nuevas mientras el trabajo terminado espera revisión humana. Desactivado por defecto. «Avisar» añade una confirmación; «Aplicar» rechaza la creación al superar un límite estricto.",
+        "mode": "Modo",
+        "modes": {
+          "off": "Desactivado",
+          "warn": "Avisar (confirmar para continuar)",
+          "enforce": "Aplicar (bloqueo estricto)"
+        },
+        "warnCount": "Avisar a partir de (tareas en revisión)",
+        "enforceHint": "«Aplicar» rechaza la creación de tareas. Activa al menos un disparador estricto abajo.",
+        "blockCountToggle": "Bloquear cuando haya demasiadas tareas en revisión",
+        "blockCount": "Bloquear a partir de (tareas en revisión)",
+        "blockStuckToggle": "Bloquear cuando una tarea lleve esperando demasiado",
+        "blockStuckMinutes": "Bloquear tras (minutos de espera)",
+        "needsTrigger": "El modo «Aplicar» necesita al menos un disparador estricto activo (un recuento o un tiempo de espera)."
+      },
       "observability": {
         "heading": "Observabilidad del agente",
         "body": "Almacena el contexto completo proporcionado a cada agente: los prompts compuestos, los fragmentos de buenas prácticas incorporados y el contenido íntegro de los archivos inyectados en su contenedor, para poder inspeccionarlo después en la vista de observabilidad. Los cuerpos se conservan durante la misma ventana que la telemetría de LLM por llamada. Desactívalo para dejar de almacenarlo (las instantáneas existentes se eliminan por retención).",

package/i18n/locales/fr.json

@@ -457,6 +457,22 @@
       "mergeFailed": "Échec de la fusion",
       "restartFailed": "Échec du redémarrage"
     },
+    "reviewFriction": {
+      "warnTitle": "Tâches en attente de revue",
+      "blockedTitle": "Trop de tâches en attente de revue",
+      "warnToast": "Des tâches attendent une revue humaine. Pensez à les revoir avant de créer plus de travail.",
+      "blockedToast": "La création de tâches est bloquée jusqu’à résorption de la file de revue.",
+      "warnBody": "{count} tâche(s) attendent une revue humaine. Pensez à les revoir avant de créer plus de travail.",
+      "blockedCountBody": "Création bloquée : {count} tâche(s) attendent une revue humaine (limite {threshold}). Résorbez d’abord la file de revue.",
+      "blockedStuckBody": "Création bloquée : une tâche attend une revue humaine depuis plus de {minutes} minute(s). Résorbez d’abord la file de revue.",
+      "waitingHeading": "En attente de revue",
+      "waiting": "{minutes} min d’attente",
+      "untitled": "Tâche sans titre",
+      "close": "Fermer",
+      "createAnyway": "Créer quand même",
+      "goReview": "Aller revoir",
+      "badge": "{count} tâche(s) en attente de revue"
+    },
     "conflict": {
       "title": {
         "dependencies_unmet": "Bloqué par des dépendances",
@@ -2569,6 +2585,23 @@
         "review": "revue",
         "ralph": "Boucle Ralph"
       },
+      "reviewFriction": {
+        "heading": "Friction de dette de revue",
+        "body": "Décourage la création de nouvelles tâches tant que du travail terminé attend une revue humaine. Désactivé par défaut. « Avertir » ajoute une confirmation ; « Imposer » refuse la création au-delà d’une limite stricte.",
+        "mode": "Mode",
+        "modes": {
+          "off": "Désactivé",
+          "warn": "Avertir (confirmer pour continuer)",
+          "enforce": "Imposer (blocage strict)"
+        },
+        "warnCount": "Avertir à partir de (tâches en revue)",
+        "enforceHint": "« Imposer » refuse la création de tâches. Activez au moins un déclencheur strict ci-dessous.",
+        "blockCountToggle": "Bloquer quand trop de tâches sont en revue",
+        "blockCount": "Bloquer à partir de (tâches en revue)",
+        "blockStuckToggle": "Bloquer quand une tâche attend depuis trop longtemps",
+        "blockStuckMinutes": "Bloquer après (minutes d’attente)",
+        "needsTrigger": "Le mode « Imposer » nécessite au moins un déclencheur strict activé (un nombre ou un temps d’attente)."
+      },
       "observability": {
         "heading": "Observabilité de l'agent",
         "body": "Stockez le contexte complet fourni à chaque agent : les prompts composés, les fragments de bonnes pratiques intégrés et le contenu intégral des fichiers injectés dans son conteneur, afin de pouvoir l'inspecter plus tard dans la vue d'observabilité. Les corps sont conservés pendant la même fenêtre que la télémétrie LLM par appel. Désactivez pour cesser de le stocker (les instantanés existants sont supprimés par la rétention).",

package/i18n/locales/he.json

@@ -457,6 +457,22 @@
       "mergeFailed": "המיזוג נכשל",
       "restartFailed": "ההפעלה מחדש נכשלה"
     },
+    "reviewFriction": {
+      "warnTitle": "משימות ממתינות לסקירה",
+      "blockedTitle": "יותר מדי משימות ממתינות לסקירה",
+      "warnToast": "כמה משימות ממתינות לסקירה אנושית. שקול לסקור אותן לפני יצירת עבודה נוספת.",
+      "blockedToast": "יצירת משימות חסומה עד לצמצום תור הסקירה.",
+      "warnBody": "{count} משימות ממתינות לסקירה אנושית. שקול לסקור אותן לפני יצירת עבודה נוספת.",
+      "blockedCountBody": "היצירה חסומה: {count} משימות ממתינות לסקירה אנושית (מגבלה {threshold}). צמצם תחילה את תור הסקירה.",
+      "blockedStuckBody": "היצירה חסומה: משימה ממתינה לסקירה אנושית יותר מ־{minutes} דקות. צמצם תחילה את תור הסקירה.",
+      "waitingHeading": "ממתין לסקירה",
+      "waiting": "{minutes} דק׳ בהמתנה",
+      "untitled": "משימה ללא כותרת",
+      "close": "סגור",
+      "createAnyway": "צור בכל זאת",
+      "goReview": "עבור לסקירה",
+      "badge": "{count} משימות ממתינות לסקירה"
+    },
     "conflict": {
       "title": {
         "dependencies_unmet": "חסום על ידי תלויות",
@@ -2690,6 +2706,23 @@
         "review": "סקירה",
         "ralph": "לולאת Ralph"
       },
+      "reviewFriction": {
+        "heading": "חיכוך חוב סקירה",
+        "body": "מרתיע מיצירת משימות חדשות בזמן שעבודה שהושלמה ממתינה לסקירה אנושית. כבוי כברירת מחדל. „אזהרה” מוסיפה אישור; „אכיפה” מסרבת ליצירה מעבר לגבול קשיח.",
+        "mode": "מצב",
+        "modes": {
+          "off": "כבוי",
+          "warn": "אזהרה (אישור כדי להמשיך)",
+          "enforce": "אכיפה (חסימה קשיחה)"
+        },
+        "warnCount": "אזהרה החל מ־ (משימות בסקירה)",
+        "enforceHint": "„אכיפה” מסרבת ליצירת משימות. הפעל לפחות טריגר קשיח אחד למטה.",
+        "blockCountToggle": "חסום כשיש יותר מדי משימות בסקירה",
+        "blockCount": "חסום החל מ־ (משימות בסקירה)",
+        "blockStuckToggle": "חסום כשמשימה ממתינה יותר מדי זמן",
+        "blockStuckMinutes": "חסום לאחר (דקות המתנה)",
+        "needsTrigger": "מצב „אכיפה” דורש לפחות טריגר קשיח פעיל אחד (מספר או זמן המתנה)."
+      },
       "observability": {
         "heading": "תצפיתיות סוכנים",
         "body": "אחסן את ההקשר המלא שניתן לכל סוכן: ההנחיות המורכבות, מקטעי שיטות העבודה המומלצות שמשולבים, והתוכן המלא של הקבצים שמוזרקים לקונטיינר שלו, כך שניתן יהיה לבדוק אותו מאוחר יותר בתצוגת התצפיתיות. הגופים נשמרים לאותו חלון כמו טלמטריית ה-LLM לכל קריאה. כבה כדי להפסיק לאחסן אותו (תצלומים קיימים נגזמים לפי תקופת השמירה).",

package/i18n/locales/it.json

@@ -738,6 +738,23 @@
         "review": "revisione",
         "ralph": "Ciclo Ralph"
       },
+      "reviewFriction": {
+        "heading": "Attrito per revisioni in sospeso",
+        "body": "Scoraggia la creazione di nuove attività mentre il lavoro completato attende la revisione umana. Disattivato per impostazione predefinita. «Avvisa» aggiunge una conferma; «Imponi» rifiuta la creazione oltre un limite rigido.",
+        "mode": "Modalità",
+        "modes": {
+          "off": "Disattivato",
+          "warn": "Avvisa (conferma per procedere)",
+          "enforce": "Imponi (blocco rigido)"
+        },
+        "warnCount": "Avvisa da (attività in revisione)",
+        "enforceHint": "«Imponi» rifiuta la creazione di attività. Attiva almeno un trigger rigido qui sotto.",
+        "blockCountToggle": "Blocca quando troppe attività sono in revisione",
+        "blockCount": "Blocca da (attività in revisione)",
+        "blockStuckToggle": "Blocca quando un’attività attende da troppo tempo",
+        "blockStuckMinutes": "Blocca dopo (minuti di attesa)",
+        "needsTrigger": "La modalità «Imponi» richiede almeno un trigger rigido attivo (un conteggio o un tempo di attesa)."
+      },
       "observability": {
         "heading": "Osservabilita degli agenti",
         "body": "Memorizza il contesto completo fornito a ogni agente: i prompt composti, i frammenti di best practice inclusi e il contenuto completo dei file iniettati nel suo container, cosicche possa essere ispezionato in seguito nella vista di osservabilita. I corpi vengono conservati per la stessa finestra della telemetria LLM per chiamata. Disattiva per interrompere la memorizzazione (gli snapshot esistenti vengono eliminati dalla retention).",
@@ -4060,6 +4077,22 @@
       "mergeFailed": "Merge non riuscito",
       "restartFailed": "Riavvio non riuscito"
     },
+    "reviewFriction": {
+      "warnTitle": "Attività in attesa di revisione",
+      "blockedTitle": "Troppe attività in attesa di revisione",
+      "warnToast": "Alcune attività attendono la revisione umana. Valuta di revisionarle prima di creare altro lavoro.",
+      "blockedToast": "La creazione di attività è bloccata finché non si riduce la coda di revisione.",
+      "warnBody": "{count} attività attendono la revisione umana. Valuta di revisionarle prima di creare altro lavoro.",
+      "blockedCountBody": "Creazione bloccata: {count} attività attendono la revisione umana (limite {threshold}). Riduci prima la coda di revisione.",
+      "blockedStuckBody": "Creazione bloccata: un’attività attende la revisione umana da oltre {minutes} minuto/i. Riduci prima la coda di revisione.",
+      "waitingHeading": "In attesa di revisione",
+      "waiting": "{minutes} min di attesa",
+      "untitled": "Attività senza titolo",
+      "close": "Chiudi",
+      "createAnyway": "Crea comunque",
+      "goReview": "Vai a revisionare",
+      "badge": "{count} attività in attesa di revisione"
+    },
     "conflict": {
       "title": {
         "dependencies_unmet": "Bloccato dalle dipendenze",

package/i18n/locales/ja.json

@@ -457,6 +457,22 @@
       "mergeFailed": "マージに失敗しました",
       "restartFailed": "再起動に失敗しました"
     },
+    "reviewFriction": {
+      "warnTitle": "レビュー待ちのタスク",
+      "blockedTitle": "レビュー待ちのタスクが多すぎます",
+      "warnToast": "一部のタスクが人によるレビューを待っています。新しい作業を作成する前にレビューを検討してください。",
+      "blockedToast": "レビュー待ち行列が解消されるまで、タスクの作成はブロックされます。",
+      "warnBody": "{count} 件のタスクが人によるレビューを待っています。新しい作業を作成する前にレビューを検討してください。",
+      "blockedCountBody": "作成がブロックされました：{count} 件のタスクが人によるレビューを待っています（上限 {threshold}）。先にレビュー待ち行列を解消してください。",
+      "blockedStuckBody": "作成がブロックされました：あるタスクが {minutes} 分以上、人によるレビューを待っています。先にレビュー待ち行列を解消してください。",
+      "waitingHeading": "レビュー待ち",
+      "waiting": "待機 {minutes} 分",
+      "untitled": "無題のタスク",
+      "close": "閉じる",
+      "createAnyway": "それでも作成",
+      "goReview": "レビューへ移動",
+      "badge": "{count} 件のタスクがレビュー待ち"
+    },
     "conflict": {
       "title": {
         "dependencies_unmet": "依存関係によりブロック中",
@@ -2691,6 +2707,23 @@
         "review": "レビュー",
         "ralph": "Ralph ループ"
       },
+      "reviewFriction": {
+        "heading": "レビュー滞留の摩擦",
+        "body": "完了した作業が人によるレビューを待っている間、新しいタスクの作成を抑制します。既定ではオフ。「警告」は確認ステップを追加し、「強制」は厳格な上限を超えると作成を完全に拒否します。",
+        "mode": "モード",
+        "modes": {
+          "off": "オフ",
+          "warn": "警告（確認して続行）",
+          "enforce": "強制（ハードブロック）"
+        },
+        "warnCount": "警告するしきい値（レビュー中のタスク数）",
+        "enforceHint": "「強制」はタスク作成を拒否します。下で少なくとも1つのハードトリガーを有効にしてください。",
+        "blockCountToggle": "レビュー中のタスクが多すぎる場合にブロック",
+        "blockCount": "ブロックするしきい値（レビュー中のタスク数）",
+        "blockStuckToggle": "タスクの待機が長すぎる場合にブロック",
+        "blockStuckMinutes": "ブロックするまでの時間（待機分数）",
+        "needsTrigger": "「強制」モードには、有効なハードトリガーが少なくとも1つ必要です（件数または待機時間）。"
+      },
       "observability": {
         "heading": "エージェントの可観測性",
         "body": "各エージェントに提供された完全なコンテキストを保存します。構成されたプロンプト、折り込まれたベストプラクティスのフラグメント、コンテナに注入されたファイルの全内容を保存し、後から可観測性ビューで確認できます。本文は呼び出しごとの LLM テレメトリと同じ期間だけ保持されます。オフにすると保存を停止します (既存のスナップショットは保持期限により削除されます)。",

package/i18n/locales/pl.json

@@ -457,6 +457,22 @@
       "mergeFailed": "Nie udało się scalić",
       "restartFailed": "Nie udało się ponownie uruchomić"
     },
+    "reviewFriction": {
+      "warnTitle": "Zadania czekające na przegląd",
+      "blockedTitle": "Zbyt wiele zadań czeka na przegląd",
+      "warnToast": "Niektóre zadania czekają na przegląd przez człowieka. Rozważ ich przejrzenie przed tworzeniem kolejnej pracy.",
+      "blockedToast": "Tworzenie zadań jest zablokowane do czasu zmniejszenia kolejki przeglądów.",
+      "warnBody": "{count} zadań czeka na przegląd przez człowieka. Rozważ ich przejrzenie przed tworzeniem kolejnej pracy.",
+      "blockedCountBody": "Tworzenie zablokowane: {count} zadań czeka na przegląd przez człowieka (limit {threshold}). Najpierw zmniejsz kolejkę przeglądów.",
+      "blockedStuckBody": "Tworzenie zablokowane: zadanie czeka na przegląd przez człowieka od ponad {minutes} minut(y). Najpierw zmniejsz kolejkę przeglądów.",
+      "waitingHeading": "Oczekujące na przegląd",
+      "waiting": "{minutes} min oczekiwania",
+      "untitled": "Zadanie bez tytułu",
+      "close": "Zamknij",
+      "createAnyway": "Utwórz mimo to",
+      "goReview": "Przejdź do przeglądu",
+      "badge": "{count} zadań czeka na przegląd"
+    },
     "conflict": {
       "title": {
         "dependencies_unmet": "Zablokowane przez zależności",
@@ -2569,6 +2585,23 @@
         "review": "przegląd",
         "ralph": "Pętla Ralph"
       },
+      "reviewFriction": {
+        "heading": "Hamulec długu przeglądów",
+        "body": "Zniechęca do tworzenia nowych zadań, gdy ukończona praca czeka na przegląd przez człowieka. Domyślnie wyłączone. „Ostrzegaj” dodaje potwierdzenie; „Wymuszaj” całkowicie odmawia utworzenia po przekroczeniu twardego limitu.",
+        "mode": "Tryb",
+        "modes": {
+          "off": "Wyłączone",
+          "warn": "Ostrzegaj (potwierdź, aby kontynuować)",
+          "enforce": "Wymuszaj (twarda blokada)"
+        },
+        "warnCount": "Ostrzegaj od (zadań w przeglądzie)",
+        "enforceHint": "„Wymuszaj” odmawia tworzenia zadań. Włącz poniżej co najmniej jeden twardy wyzwalacz.",
+        "blockCountToggle": "Blokuj, gdy zbyt wiele zadań jest w przeglądzie",
+        "blockCount": "Blokuj od (zadań w przeglądzie)",
+        "blockStuckToggle": "Blokuj, gdy zadanie czeka zbyt długo",
+        "blockStuckMinutes": "Blokuj po (minutach oczekiwania)",
+        "needsTrigger": "Tryb „Wymuszaj” wymaga włączenia co najmniej jednego twardego wyzwalacza (liczby lub czasu oczekiwania)."
+      },
       "observability": {
         "heading": "Obserwowalność agenta",
         "body": "Przechowuj pełny kontekst przekazany każdemu agentowi: złożone prompty, włączone fragmenty dobrych praktyk oraz pełną treść plików wstrzykniętych do jego kontenera, aby można było je później sprawdzić w widoku obserwowalności. Treści są przechowywane przez to samo okno co telemetria LLM dla poszczególnych wywołań. Wyłącz, aby przestać je przechowywać (istniejące migawki są usuwane przez retencję).",

package/i18n/locales/tr.json

@@ -457,6 +457,22 @@
       "mergeFailed": "Birleştirilemedi",
       "restartFailed": "Yeniden başlatılamadı"
     },
+    "reviewFriction": {
+      "warnTitle": "Görevler incelemeyi bekliyor",
+      "blockedTitle": "Çok fazla görev incelemeyi bekliyor",
+      "warnToast": "Bazı görevler insan incelemesini bekliyor. Daha fazla iş oluşturmadan önce onları incelemeyi düşünün.",
+      "blockedToast": "İnceleme kuyruğu azaltılana kadar görev oluşturma engellendi.",
+      "warnBody": "{count} görev insan incelemesini bekliyor. Daha fazla iş oluşturmadan önce onları incelemeyi düşünün.",
+      "blockedCountBody": "Oluşturma engellendi: {count} görev insan incelemesini bekliyor (sınır {threshold}). Önce inceleme kuyruğunu azaltın.",
+      "blockedStuckBody": "Oluşturma engellendi: bir görev {minutes} dakikadan uzun süredir insan incelemesini bekliyor. Önce inceleme kuyruğunu azaltın.",
+      "waitingHeading": "İncelemeyi bekliyor",
+      "waiting": "{minutes} dk bekliyor",
+      "untitled": "Başlıksız görev",
+      "close": "Kapat",
+      "createAnyway": "Yine de oluştur",
+      "goReview": "İncelemeye git",
+      "badge": "{count} görev incelemeyi bekliyor"
+    },
     "conflict": {
       "title": {
         "dependencies_unmet": "Bağımlılıklar tarafından engellendi",
@@ -2691,6 +2707,23 @@
         "review": "inceleme",
         "ralph": "Ralph döngüsü"
       },
+      "reviewFriction": {
+        "heading": "İnceleme borcu sürtünmesi",
+        "body": "Tamamlanan iş insan incelemesini beklerken yeni görev oluşturmayı caydırır. Varsayılan olarak kapalı. «Uyar» bir onay adımı ekler; «Zorla» katı bir sınırın ötesinde oluşturmayı tümüyle reddeder.",
+        "mode": "Mod",
+        "modes": {
+          "off": "Kapalı",
+          "warn": "Uyar (devam için onayla)",
+          "enforce": "Zorla (katı engel)"
+        },
+        "warnCount": "Şu sayıda uyar (incelemedeki görevler)",
+        "enforceHint": "«Zorla» görev oluşturmayı reddeder. Aşağıda en az bir katı tetikleyici etkinleştirin.",
+        "blockCountToggle": "İncelemede çok fazla görev olduğunda engelle",
+        "blockCount": "Şu sayıda engelle (incelemedeki görevler)",
+        "blockStuckToggle": "Bir görev çok uzun süre beklediğinde engelle",
+        "blockStuckMinutes": "Şu süreden sonra engelle (dakika bekleme)",
+        "needsTrigger": "«Zorla» modu en az bir etkin katı tetikleyici gerektirir (bir sayı veya bir bekleme süresi)."
+      },
       "observability": {
         "heading": "Agent gözlemlenebilirliği",
         "body": "Her agent'a sağlanan tüm bağlamı saklayın: oluşturulan istemler, içine katlanan en iyi uygulama parçaları ve konteynerine enjekte edilen dosyaların tam içeriği; böylece daha sonra gözlemlenebilirlik görünümünde incelenebilir. Gövdeler, çağrı başına LLM telemetrisi ile aynı süre boyunca tutulur. Saklamayı durdurmak için kapatın (mevcut anlık görüntüler saklama ilkesiyle temizlenir).",

package/i18n/locales/uk.json

@@ -457,6 +457,22 @@
       "mergeFailed": "Не вдалося злити",
       "restartFailed": "Не вдалося перезапустити"
     },
+    "reviewFriction": {
+      "warnTitle": "Завдання чекають на рев’ю",
+      "blockedTitle": "Забагато завдань чекають на рев’ю",
+      "warnToast": "Деякі завдання чекають на рев’ю людиною. Розгляньте можливість переглянути їх, перш ніж створювати більше роботи.",
+      "blockedToast": "Створення завдань заблоковано, доки не зменшиться черга рев’ю.",
+      "warnBody": "{count} завдань(ня) чекають на рев’ю людиною. Розгляньте можливість переглянути їх, перш ніж створювати більше роботи.",
+      "blockedCountBody": "Створення заблоковано: {count} завдань(ня) чекають на рев’ю людиною (ліміт {threshold}). Спершу зменшіть чергу рев’ю.",
+      "blockedStuckBody": "Створення заблоковано: завдання чекає на рев’ю людиною понад {minutes} хвилин(и). Спершу зменшіть чергу рев’ю.",
+      "waitingHeading": "Очікують на рев’ю",
+      "waiting": "{minutes} хв очікування",
+      "untitled": "Завдання без назви",
+      "close": "Закрити",
+      "createAnyway": "Усе одно створити",
+      "goReview": "Перейти до рев’ю",
+      "badge": "{count} завдань(ня) чекають на рев’ю"
+    },
     "conflict": {
       "title": {
         "dependencies_unmet": "Заблоковано залежностями",
@@ -2569,6 +2585,23 @@
         "review": "огляд",
         "ralph": "Цикл Ralph"
       },
+      "reviewFriction": {
+        "heading": "Тертя через борг рев’ю",
+        "body": "Ускладнює створення нових завдань, поки завершена робота чекає на рев’ю людиною. Типово вимкнено. «Попереджати» додає підтвердження; «Примусово» повністю відмовляє у створенні після досягнення жорсткого ліміту.",
+        "mode": "Режим",
+        "modes": {
+          "off": "Вимкнено",
+          "warn": "Попереджати (підтвердити, щоб продовжити)",
+          "enforce": "Примусово (жорстке блокування)"
+        },
+        "warnCount": "Попереджати від (завдань на рев’ю)",
+        "enforceHint": "«Примусово» відмовляє у створенні завдань. Увімкніть принаймні один жорсткий тригер нижче.",
+        "blockCountToggle": "Блокувати, коли забагато завдань на рев’ю",
+        "blockCount": "Блокувати від (завдань на рев’ю)",
+        "blockStuckToggle": "Блокувати, коли завдання чекає надто довго",
+        "blockStuckMinutes": "Блокувати після (хвилин очікування)",
+        "needsTrigger": "Режим «Примусово» потребує принаймні одного увімкненого жорсткого тригера (кількості або часу очікування)."
+      },
       "observability": {
         "heading": "Спостережуваність агента",
         "body": "Зберігайте повний контекст, наданий кожному агенту: складені промпти, вбудовані фрагменти найкращих практик і повний вміст файлів, впроваджених у його контейнер, щоб згодом їх можна було переглянути у вікні спостережуваності. Тіла зберігаються протягом того самого вікна, що й телеметрія LLM для кожного виклику. Вимкніть, щоб припинити зберігання (наявні знімки видаляються за політикою зберігання).",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cat-factory/app",
-  "version": "0.150.1",
+  "version": "0.151.0",
   "description": "Reusable Nuxt layer for the Agent Architecture Board SPA (components, stores, composables, pages). Consume it from a thin deployment app via `extends: ['@cat-factory/app']` and point it at your backend with NUXT_PUBLIC_API_BASE. See deploy/frontend for an example.",
   "repository": {
     "type": "git",
@@ -40,7 +40,7 @@
     "valibot": "^1.4.2",
     "vue": "3.5.40",
     "wretch": "^3.0.9",
-    "@cat-factory/contracts": "0.158.0"
+    "@cat-factory/contracts": "0.159.0"
   },
   "devDependencies": {
     "@toad-contracts/testing": "0.3.2",