@cat-factory/app 0.150.0 → 0.151.0

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',
+  },
 }
 
 /**
@@ -186,200 +198,231 @@ export function parseConflict(
   }
 }
 
+/** The non-null parsed shape of a backend conflict, as returned by {@link parseConflict}. */
+type ParsedConflict = NonNullable<ReturnType<typeof parseConflict>>
+
 export function usePipelineErrorToast() {
   const toast = useToast()
   const ui = useUiStore()
   const { t, te } = useI18n()
 
-  /**
-   * Present `error` as a toast. `fallbackTitleKey` is an i18n message key used for
-   * non-conflict failures and any conflict reason without a dedicated title.
-   */
-  function present(error: unknown, fallbackTitleKey = 'common.actionFailed'): void {
-    const conflict = parseConflict(error)
+  // The headline case: a pipeline step's model has no usable provider. Name the
+  // offending model(s), explain no provider is available, and offer the one-click jump
+  // to the AI setup — the same remedy the startup "No AI model configured" banner gives.
+  function presentProvidersUnconfigured(conflict: ParsedConflict): void {
+    const models = Array.isArray(conflict.details.models) ? conflict.details.models : []
+    const list = models.join(', ')
+    toast.add({
+      title: t('errors.conflict.providersUnconfigured.title'),
+      description: list
+        ? t('errors.conflict.providersUnconfigured.body', { models: list })
+        : (conflict.message ?? t('errors.conflict.fallbackMessage')),
+      color: 'error',
+      icon: 'i-lucide-cpu',
+      // Stay until dismissed: an actionable toast whose remedy button vanishes on the ~5s
+      // auto-dismiss takes the one-click fix with it before the user can reach it.
+      duration: 0,
+      actions: [
+        {
+          label: t('errors.conflict.providersUnconfigured.action'),
+          icon: 'i-lucide-settings',
+          onClick: () => ui.openAiProviderSetup(),
+        },
+      ],
+    })
+  }
 
-    // The headline case: a pipeline step's model has no usable provider. Name the
-    // offending model(s), explain no provider is available, and offer the one-click jump
-    // to the AI setup — the same remedy the startup "No AI model configured" banner gives.
-    if (conflict?.reason === 'providers_unconfigured') {
-      const models = Array.isArray(conflict.details.models) ? conflict.details.models : []
-      const list = models.join(', ')
-      toast.add({
-        title: t('errors.conflict.providersUnconfigured.title'),
-        description: list
-          ? t('errors.conflict.providersUnconfigured.body', { models: list })
-          : (conflict.message ?? t('errors.conflict.fallbackMessage')),
-        color: 'error',
-        icon: 'i-lucide-cpu',
-        // Stay until dismissed: an actionable toast whose remedy button vanishes on the ~5s
-        // auto-dismiss takes the one-click fix with it before the user can reach it.
-        duration: 0,
-        actions: [
-          {
-            label: t('errors.conflict.providersUnconfigured.action'),
-            icon: 'i-lucide-settings',
-            onClick: () => ui.openAiProviderSetup(),
-          },
-        ],
-      })
-      return
-    }
+  // A pipeline step relies on binary-artifact storage (the UI Tester uploads screenshots)
+  // but the account has none configured. Explain it and offer the jump to the content-storage
+  // settings — the same shape as the providers-unconfigured case above. Prefer the localized
+  // body (it carries no runtime interpolation) so non-English users see translated copy; the
+  // raw backend prose is only the last-resort fallback when the locale lacks the key.
+  function presentBinaryStorageUnconfigured(conflict: ParsedConflict): void {
+    toast.add({
+      title: t('errors.conflict.binaryStorageUnconfigured.title'),
+      description: te('errors.conflict.binaryStorageUnconfigured.body')
+        ? t('errors.conflict.binaryStorageUnconfigured.body')
+        : (conflict.message ?? t('errors.conflict.fallbackMessage')),
+      color: 'error',
+      icon: 'i-lucide-image',
+      // Sticky, like the providers-unconfigured toast above: keep the "Configure storage"
+      // remedy reachable instead of letting it auto-dismiss.
+      duration: 0,
+      actions: [
+        {
+          label: t('errors.conflict.binaryStorageUnconfigured.action'),
+          icon: 'i-lucide-settings',
+          onClick: () => ui.openContentStorageSettings(),
+        },
+      ],
+    })
+  }
 
-    // A pipeline step relies on binary-artifact storage (the UI Tester uploads screenshots)
-    // but the account has none configured. Explain it and offer the jump to the content-storage
-    // settings — the same shape as the providers-unconfigured case above. Prefer the localized
-    // body (it carries no runtime interpolation) so non-English users see translated copy; the
-    // raw backend prose is only the last-resort fallback when the locale lacks the key.
-    if (conflict?.reason === 'binary_storage_unconfigured') {
-      toast.add({
-        title: t('errors.conflict.binaryStorageUnconfigured.title'),
-        description: te('errors.conflict.binaryStorageUnconfigured.body')
-          ? t('errors.conflict.binaryStorageUnconfigured.body')
-          : (conflict.message ?? t('errors.conflict.fallbackMessage')),
-        color: 'error',
-        icon: 'i-lucide-image',
-        // Sticky, like the providers-unconfigured toast above: keep the "Configure storage"
-        // remedy reachable instead of letting it auto-dismiss.
-        duration: 0,
-        actions: [
-          {
-            label: t('errors.conflict.binaryStorageUnconfigured.action'),
-            icon: 'i-lucide-settings',
-            onClick: () => ui.openContentStorageSettings(),
+  // A pipeline includes a Deployer, but the SERVICE's ephemeral-environment config (the in-repo
+  // "what/where") is incomplete for its declared type. Steer the user straight to THAT service's
+  // environment config — the compose wizard for docker-compose, the service inspector otherwise —
+  // falling back to the workspace infrastructure window if the frame id wasn't carried.
+  function presentDeployerServiceConfig(conflict: ParsedConflict): void {
+    const frameId =
+      typeof conflict.details.frameId === 'string' ? conflict.details.frameId : undefined
+    const provisionType =
+      typeof conflict.details.provisionType === 'string'
+        ? conflict.details.provisionType
+        : undefined
+    const missing = Array.isArray(conflict.details.missing)
+      ? conflict.details.missing.join(', ')
+      : ''
+    toast.add({
+      title: t('errors.conflict.deployerServiceConfig.title'),
+      description: missing
+        ? t('errors.conflict.deployerServiceConfig.body', { missing })
+        : (conflict.message ?? t('errors.conflict.fallbackMessage')),
+      color: 'error',
+      icon: 'i-lucide-server',
+      // Sticky, like the other actionable conflicts: keep the "Fix configuration" jump reachable.
+      duration: 0,
+      actions: [
+        {
+          label: t('errors.conflict.deployerServiceConfig.action'),
+          icon: 'i-lucide-settings',
+          onClick: () => {
+            if (frameId && provisionType === 'docker-compose') ui.openEnvironmentSetup(frameId)
+            else if (frameId) ui.select(frameId)
+            else ui.openProviderConnection('environment')
           },
-        ],
-      })
-      return
-    }
+        },
+      ],
+    })
+  }
 
-    // A pipeline includes a Deployer, but the SERVICE's ephemeral-environment config (the in-repo
-    // "what/where") is incomplete for its declared type. Steer the user straight to THAT service's
-    // environment config — the compose wizard for docker-compose, the service inspector otherwise —
-    // falling back to the workspace infrastructure window if the frame id wasn't carried.
-    if (conflict?.reason === 'deployer_service_provisioning_incomplete') {
-      const frameId =
-        typeof conflict.details.frameId === 'string' ? conflict.details.frameId : undefined
-      const provisionType =
-        typeof conflict.details.provisionType === 'string'
-          ? conflict.details.provisionType
-          : undefined
-      const missing = Array.isArray(conflict.details.missing)
-        ? conflict.details.missing.join(', ')
-        : ''
-      toast.add({
-        title: t('errors.conflict.deployerServiceConfig.title'),
-        description: missing
-          ? t('errors.conflict.deployerServiceConfig.body', { missing })
-          : (conflict.message ?? t('errors.conflict.fallbackMessage')),
-        color: 'error',
-        icon: 'i-lucide-server',
-        // Sticky, like the other actionable conflicts: keep the "Fix configuration" jump reachable.
-        duration: 0,
-        actions: [
-          {
-            label: t('errors.conflict.deployerServiceConfig.action'),
-            icon: 'i-lucide-settings',
-            onClick: () => {
-              if (frameId && provisionType === 'docker-compose') ui.openEnvironmentSetup(frameId)
-              else if (frameId) ui.select(frameId)
-              else ui.openProviderConnection('environment')
-            },
-          },
-        ],
-      })
-      return
-    }
+  // A pipeline includes a Deployer and the service config is sound, but no WORKSPACE handler
+  // resolves for the service's provision type (missing or ambiguous). Steer to the Infrastructure
+  // window's Test-environments tab. (Also raised by the Tester start gate — same fix applies.)
+  function presentProvisionTypeUnhandled(conflict: ParsedConflict): void {
+    const type =
+      typeof conflict.details.provisionType === 'string' ? conflict.details.provisionType : ''
+    toast.add({
+      title: t('errors.conflict.provisionTypeUnhandled.title'),
+      description: type
+        ? t('errors.conflict.provisionTypeUnhandled.body', { type })
+        : (conflict.message ?? t('errors.conflict.fallbackMessage')),
+      color: 'error',
+      icon: 'i-lucide-server-cog',
+      duration: 0,
+      actions: [
+        {
+          label: t('errors.conflict.provisionTypeUnhandled.action'),
+          icon: 'i-lucide-settings',
+          onClick: () => ui.openProviderConnection('environment'),
+        },
+      ],
+    })
+  }
 
-    // A pipeline includes a Deployer and the service config is sound, but no WORKSPACE handler
-    // resolves for the service's provision type (missing or ambiguous). Steer to the Infrastructure
-    // window's Test-environments tab. (Also raised by the Tester start gate — same fix applies.)
-    if (conflict?.reason === 'provision_type_unhandled') {
-      const type =
-        typeof conflict.details.provisionType === 'string' ? conflict.details.provisionType : ''
-      toast.add({
-        title: t('errors.conflict.provisionTypeUnhandled.title'),
-        description: type
-          ? t('errors.conflict.provisionTypeUnhandled.body', { type })
-          : (conflict.message ?? t('errors.conflict.fallbackMessage')),
-        color: 'error',
-        icon: 'i-lucide-server-cog',
-        duration: 0,
-        actions: [
-          {
-            label: t('errors.conflict.provisionTypeUnhandled.action'),
-            icon: 'i-lucide-settings',
-            onClick: () => ui.openProviderConnection('environment'),
-          },
-        ],
-      })
-      return
+  // A pipeline includes a Deployer, the config is structurally complete, but the live connection
+  // probe of the resolved deployment integration failed (unreachable endpoint / apiserver, bad
+  // token). Surface the provider's failure detail and steer to the handler to fix + re-test it.
+  function presentDeployerConnectionFailed(conflict: ParsedConflict): void {
+    const detail = typeof conflict.details.detail === 'string' ? conflict.details.detail : undefined
+    toast.add({
+      title: t('errors.conflict.deployerConnectionFailed.title'),
+      description: detail
+        ? t('errors.conflict.deployerConnectionFailed.body', { detail })
+        : (conflict.message ?? t('errors.conflict.fallbackMessage')),
+      color: 'error',
+      icon: 'i-lucide-plug',
+      duration: 0,
+      actions: [
+        {
+          label: t('errors.conflict.deployerConnectionFailed.action'),
+          icon: 'i-lucide-settings',
+          onClick: () => ui.openProviderConnection('environment'),
+        },
+      ],
+    })
+  }
+
+  /**
+   * Dispatch the bespoke conflict reasons (a runtime-interpolated body + a "configure X" action,
+   * each with its own key namespace — the ones excluded from `CONFLICT_INFO`). Returns `true` when
+   * the reason was one of them (and the toast was raised), `false` to fall through to the generic
+   * map. The reason values are mutually exclusive, so dispatch order is irrelevant.
+   */
+  function presentBespokeConflict(conflict: ParsedConflict): boolean {
+    switch (conflict.reason) {
+      case 'providers_unconfigured':
+        presentProvidersUnconfigured(conflict)
+        return true
+      case 'binary_storage_unconfigured':
+        presentBinaryStorageUnconfigured(conflict)
+        return true
+      case 'deployer_service_provisioning_incomplete':
+        presentDeployerServiceConfig(conflict)
+        return true
+      case 'provision_type_unhandled':
+        presentProvisionTypeUnhandled(conflict)
+        return true
+      case 'deployer_connection_test_failed':
+        presentDeployerConnectionFailed(conflict)
+        return true
+      default:
+        return false
     }
+  }
 
-    // A pipeline includes a Deployer, the config is structurally complete, but the live connection
-    // probe of the resolved deployment integration failed (unreachable endpoint / apiserver, bad
-    // token). Surface the provider's failure detail and steer to the handler to fix + re-test it.
-    if (conflict?.reason === 'deployer_connection_test_failed') {
-      const detail =
-        typeof conflict.details.detail === 'string' ? conflict.details.detail : undefined
+  /**
+   * Per-reason copy from the exhaustive map: a translated title + description, and a jump
+   * action for the reasons a UI panel can fix. `te` (translation-exists) guards every lookup,
+   * so a key missing from the active locale falls back rather than leaking a raw key: the
+   * title falls to the caller's key, the description to the raw backend `message`. An unknown
+   * reason (not in the map) gets the same generic title + raw-message fallback.
+   */
+  function presentMappedConflict(conflict: ParsedConflict, fallbackTitleKey: string): void {
+    const info = conflict.reason
+      ? CONFLICT_INFO[conflict.reason as Exclude<ConflictReason, BespokeConflictReason>]
+      : undefined
+    if (info) {
       toast.add({
-        title: t('errors.conflict.deployerConnectionFailed.title'),
-        description: detail
-          ? t('errors.conflict.deployerConnectionFailed.body', { detail })
+        title: te(info.titleKey) ? t(info.titleKey) : t(fallbackTitleKey),
+        description: te(info.descriptionKey)
+          ? t(info.descriptionKey)
           : (conflict.message ?? t('errors.conflict.fallbackMessage')),
-        color: 'error',
-        icon: 'i-lucide-plug',
-        duration: 0,
-        actions: [
-          {
-            label: t('errors.conflict.deployerConnectionFailed.action'),
-            icon: 'i-lucide-settings',
-            onClick: () => ui.openProviderConnection('environment'),
-          },
-        ],
+        color: 'warning',
+        icon: 'i-lucide-triangle-alert',
+        // A reason with a jump action becomes an actionable, sticky toast (like the bespoke
+        // conflicts above) so the one-click remedy doesn't auto-dismiss before it's reached.
+        ...(info.action
+          ? {
+              duration: 0,
+              actions: [
+                {
+                  label: t(info.action.labelKey),
+                  icon: info.action.icon,
+                  onClick: () => info.action?.run(ui),
+                },
+              ],
+            }
+          : {}),
       })
       return
     }
+    toast.add({
+      title: t(fallbackTitleKey),
+      description: conflict.message ?? t('errors.conflict.fallbackMessage'),
+      color: 'warning',
+      icon: 'i-lucide-triangle-alert',
+    })
+  }
 
+  /**
+   * Present `error` as a toast. `fallbackTitleKey` is an i18n message key used for
+   * non-conflict failures and any conflict reason without a dedicated title.
+   */
+  function present(error: unknown, fallbackTitleKey = 'common.actionFailed'): void {
+    const conflict = parseConflict(error)
     if (conflict) {
-      // Per-reason copy from the exhaustive map: a translated title + description, and a jump
-      // action for the reasons a UI panel can fix. `te` (translation-exists) guards every lookup,
-      // so a key missing from the active locale falls back rather than leaking a raw key: the
-      // title falls to the caller's key, the description to the raw backend `message`. An unknown
-      // reason (not in the map) gets the same generic title + raw-message fallback.
-      const info = conflict.reason
-        ? CONFLICT_INFO[conflict.reason as Exclude<ConflictReason, BespokeConflictReason>]
-        : undefined
-      if (info) {
-        toast.add({
-          title: te(info.titleKey) ? t(info.titleKey) : t(fallbackTitleKey),
-          description: te(info.descriptionKey)
-            ? t(info.descriptionKey)
-            : (conflict.message ?? t('errors.conflict.fallbackMessage')),
-          color: 'warning',
-          icon: 'i-lucide-triangle-alert',
-          // A reason with a jump action becomes an actionable, sticky toast (like the bespoke
-          // conflicts above) so the one-click remedy doesn't auto-dismiss before it's reached.
-          ...(info.action
-            ? {
-                duration: 0,
-                actions: [
-                  {
-                    label: t(info.action.labelKey),
-                    icon: info.action.icon,
-                    onClick: () => info.action?.run(ui),
-                  },
-                ],
-              }
-            : {}),
-        })
-        return
-      }
-      toast.add({
-        title: t(fallbackTitleKey),
-        description: conflict.message ?? t('errors.conflict.fallbackMessage'),
-        color: 'warning',
-        icon: 'i-lucide-triangle-alert',
-      })
+      if (presentBespokeConflict(conflict)) return
+      presentMappedConflict(conflict, fallbackTitleKey)
       return
     }
 

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",