@cat-factory/app 0.282.2 → 0.283.0

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

@@ -1,9 +1,12 @@
 <script setup lang="ts">
-// Compact display of a task's estimator triage (Complexity / Risk / Impact), shown on the
-// inspector once a `task-estimator` step has run. Read-only — produced by the estimator,
-// used to gate consensus steps. Hidden when no estimate exists.
+// Compact display of a task's triage scores (Complexity / Risk / Impact), shown on the inspector
+// once a step has produced them. Read-only: a `task-estimator` step FORECASTS them before the work
+// starts and a `task-reassessor` step MEASURES them afterwards from the change that landed, so the
+// section says which reading it is showing, names the reading it corrected, and shows the earlier
+// number beside each axis that actually moved. Hidden when no estimate exists.
 import { computed } from 'vue'
 import type { Block } from '~/types/domain'
+import { estimateBasisLabelKey } from '~/utils/estimateGating'
 import InspectorSection from '~/components/panels/inspector/InspectorSection.vue'
 
 const props = defineProps<{ block: Block }>()
@@ -11,14 +14,53 @@ const { t, n } = useI18n()
 
 const estimate = computed(() => props.block.estimate ?? null)
 
-const AXES = computed(
-  () =>
+/**
+ * The three axes with both readings, so the template asks nothing about which one to show.
+ *
+ * `was` is present only where the superseded reading DIFFERS. An axis whose score did not move
+ * renders "was 40% 40%", which reads as a correction that did not happen; and the interesting
+ * thing about a re-measurement is exactly which axes it moved.
+ */
+const AXES = computed(() => {
+  const current = estimate.value
+  const prior = current?.supersedes ?? null
+  return (
     [
       { key: 'complexity', label: t('inspector.estimate.complexity') },
       { key: 'risk', label: t('inspector.estimate.risk') },
       { key: 'impact', label: t('inspector.estimate.impact') },
-    ] as const,
-)
+    ] as const
+  ).map((axis) => ({
+    ...axis,
+    was:
+      prior && current && prior[axis.key] !== current[axis.key]
+        ? n(prior[axis.key], { key: 'percent' })
+        : null,
+  }))
+})
+
+/**
+ * What this reading is, in one line. Which key that is lives in `utils/estimateGating`, beside the
+ * rest of the estimate presentation vocabulary and under test: `basis` is PERSISTED and read back
+ * without a schema pass, so absent, known and unrecognised are three distinct answers.
+ */
+const basisLabel = computed(() => t(estimateBasisLabelKey(estimate.value?.basis)))
+
+/**
+ * What the current reading REPLACED, named by ITS basis rather than left implicit.
+ *
+ * A "was 80%" chip beside a header reading "Forecast before the work started" says the earlier
+ * number was an earlier forecast, and after a re-run of the estimator on a measured task that is
+ * the wrong way round: the superseded reading is the MEASUREMENT. The backend summary prefixes the
+ * same movement with the same label for the same reason.
+ */
+const supersededLabel = computed(() => {
+  const prior = estimate.value?.supersedes
+  if (!prior) return null
+  return t('inspector.estimate.supersededBasis', {
+    basis: t(estimateBasisLabelKey(prior.basis)),
+  })
+})
 
 /** Cool→hot bar colour by severity (low = sky, mid = amber, high = rose). */
 function barClass(n: number): string {
@@ -37,6 +79,14 @@ function barClass(n: number): string {
     default-open
   >
     <div class="space-y-1.5 rounded-lg border border-slate-800 bg-slate-900/40 p-2.5">
+      <p class="text-[11px] text-slate-500" data-testid="task-estimate-basis">{{ basisLabel }}</p>
+      <p
+        v-if="supersededLabel"
+        class="text-[11px] text-slate-500"
+        data-testid="task-estimate-superseded"
+      >
+        {{ supersededLabel }}
+      </p>
       <div v-for="axis in AXES" :key="axis.key" class="flex items-center gap-2">
         <span class="w-20 shrink-0 text-xs text-slate-400">{{ axis.label }}</span>
         <div class="h-1.5 flex-1 overflow-hidden rounded-full bg-slate-800">
@@ -46,6 +96,12 @@ function barClass(n: number): string {
             :style="{ width: `${Math.round(estimate[axis.key] * 100)}%` }"
           />
         </div>
+        <span
+          v-if="axis.was"
+          class="shrink-0 text-[11px] tabular-nums text-slate-500"
+          :data-testid="`task-estimate-was-${axis.key}`"
+          >{{ t('inspector.estimate.was', { value: axis.was }) }}</span
+        >
         <span class="w-9 shrink-0 text-end text-xs tabular-nums text-slate-300">{{
           n(estimate[axis.key], { key: 'percent' })
         }}</span>

package/app/composables/usePipelineDraftWarnings.ts

@@ -1,6 +1,7 @@
 import { computed, type ComputedRef } from 'vue'
 import {
   pipelineEnvironmentProblems,
+  producesTaskEstimate,
   purposeAllowsAgentCategory,
   type PipelineEnvironmentProblemReason,
 } from '@cat-factory/contracts'
@@ -60,13 +61,14 @@ export function usePipelineDraftWarnings(
 
   const enabled = (i: number) => pipelines.draftEnabled[i] !== false
 
-  // A gated step with no task-estimator before it (mirrors `assertValidGating`, which rejects the
-  // save and the start). Both the step's own estimate gate (`draftGating`) and the Tester QC
-  // companion's (`draftTesterQuality[i].gating`) count.
+  // A gated step with no estimate PRODUCER before it (mirrors `assertValidGating`, which rejects
+  // the save and the start). Both the step's own estimate gate (`draftGating`) and the Tester QC
+  // companion's (`draftTesterQuality[i].gating`) count, and either producer satisfies it: the
+  // estimator forecasts the estimate up front, the reassessor measures it once the change lands.
   const gatingNeedsEstimator = computed(() => {
     const kinds = pipelines.draft
     const hasEstimatorBefore = (i: number) =>
-      kinds.slice(0, i).some((k, j) => k === 'task-estimator' && enabled(j))
+      kinds.slice(0, i).some((k, j) => producesTaskEstimate(k) && enabled(j))
     return kinds.some((_, i) => {
       if (!enabled(i)) return false
       const gated =

package/app/composables/usePipelineHealth.spec.ts

@@ -133,7 +133,7 @@ describe('usePipelineHealth', () => {
     expect(invalid.value[0]!.problems.some((p) => p.type === 'shape')).toBe(true)
   })
 
-  it('flags an estimate-gated companion with no task-estimator before it (shape)', () => {
+  it('flags an estimate-gated companion with no estimate producer before it (shape)', () => {
     const gated = builtin(['coder', 'reviewer'], {
       gating: [null, { enabled: true, minComplexity: 0.5, onMissingEstimate: 'run' }],
     })
@@ -142,6 +142,18 @@ describe('usePipelineHealth', () => {
     expect(invalid.value[0]!.problems.some((p) => p.type === 'shape')).toBe(true)
   })
 
+  // The estimate has two producers, at opposite ends of a run, and this advisory reads the SAME
+  // `producesTaskEstimate` predicate the engine's `assertValidGating` does. A copy that knew only
+  // the estimator would call a perfectly saveable pipeline invalid, in the surface that auto-opens
+  // a modal over the board.
+  it('accepts a gated step preceded by a task-reassessor instead of an estimator', () => {
+    const measured = builtin(['coder', 'task-reassessor', 'human-review'], {
+      gating: [null, null, { enabled: true, minRisk: 0.6, onMissingEstimate: 'run' }],
+    })
+    const { hasIssues } = scan([measured])
+    expect(hasIssues.value).toBe(false)
+  })
+
   // The regression this pins: the advisory carried its own "only a companion may be gated" rule,
   // so when the engine generalised gating to `BUILTIN_GATABLE_KINDS` the shipped `pl_simple`
   // ("Adaptive build" — an estimate-gated `architect`) was reported invalid in EVERY workspace.

package/app/composables/usePipelineHealth.ts

@@ -1,13 +1,10 @@
 import { computed } from 'vue'
 import type { Pipeline } from '~/types/domain'
 import type { StepGating } from '~/types/consensus'
-import { isBuiltinGatableKind } from '@cat-factory/contracts'
+import { isBuiltinGatableKind, producesTaskEstimate } from '@cat-factory/contracts'
 import { COMPANION_FOR_PRODUCER, isKnownAgentKind, isProducerCompanion } from '~/utils/catalog'
 import { usePipelinesStore } from '~/stores/pipelines'
 
-/** Estimate-gating consults a `task-estimator` step (mirrors the backend constant). */
-const TASK_ESTIMATOR_KIND = 'task-estimator'
-
 export type PipelineProblemType = 'unknown-kind' | 'shape' | 'outdated' | 'retired'
 
 export interface PipelineProblem {
@@ -137,9 +134,11 @@ function skipAxisProblem(
 }
 
 /**
- * Estimate gating: the shared skip-axis rules, plus the two specific to an estimate — at least one
- * axis threshold (with none the step would ALWAYS skip) and an enabled task-estimator earlier in
- * the chain (or the gate has nothing to consult). Mirrors `assertValidGating`.
+ * Estimate gating: the shared skip-axis rules, plus the two specific to an estimate: at least one
+ * axis threshold (with none the step would ALWAYS skip) and an enabled step that PRODUCES an
+ * estimate earlier in the chain (or the gate has nothing to consult). Mirrors `assertValidGating`,
+ * through the same `producesTaskEstimate` predicate, so neither surface can drift from the other
+ * about which kinds count.
  */
 function gatingProblem(p: Pipeline): string | null {
   const gating = p.gating
@@ -161,9 +160,9 @@ function gatingProblem(p: Pipeline): string | null {
     }
     const hasEstimator = kinds
       .slice(0, i)
-      .some((k, j) => k === TASK_ESTIMATOR_KIND && isEnabledAt(p, j))
+      .some((k, j) => producesTaskEstimate(k) && isEnabledAt(p, j))
     if (!hasEstimator) {
-      return `Step '${kind}' is gated on the estimate but no enabled '${TASK_ESTIMATOR_KIND}' runs before it.`
+      return `Step '${kind}' is gated on the estimate but no step that produces one runs before it.`
     }
   }
   return null

package/app/utils/catalog.spec.ts

@@ -25,6 +25,7 @@ const AGENT_KINDS: AgentKind[] = [
   'pr-reviewer',
   'spike',
   'task-estimator',
+  'task-reassessor',
   'spec-writer',
   'blueprints',
   'architect',

package/app/utils/catalog.ts

@@ -126,6 +126,24 @@ export const AGENT_ARCHETYPES: AgentArchetype[] = [
     description:
       'Triages the task after requirements are clarified — rates Complexity, Risk and Impact (0..1). Used to gate consensus and conditional companion steps, and shown as ratings on the task.',
   },
+  {
+    // The estimator's retrospective twin: it reads the change that actually landed (read-only, in a
+    // container, on the run's pull request) and re-scores the same three axes. `advanced` rather
+    // than `intermediate`: an extra container run per task is not part of the everyday delivery
+    // loop, and the everyday reader wants the forecast, not the calibration.
+    kind: 'task-reassessor',
+    tier: 'advanced',
+    label: 'Task Reassessor',
+    icon: 'i-lucide-gauge-circle',
+    color: '#f59e0b',
+    category: 'review',
+    // Reads the pull request the run opened, so it only belongs where a pipeline ships code. A
+    // document, research, planning or review pipeline opens none, and the step would be offered
+    // only to be skipped for want of a change to measure.
+    purposes: ['build'],
+    description:
+      'Re-rates Complexity, Risk and Impact after the implementation lands, from the change that was actually made. Place it after the coder: it corrects the estimator’s forecast, or produces the ratings for the first time in a pipeline that has no estimator.',
+  },
   {
     kind: 'requirements-brainstorm',
     tier: 'intermediate',

package/app/utils/estimateGating.spec.ts

@@ -4,6 +4,7 @@ import {
   ESTIMATE_AXIS_FIELD,
   ESTIMATE_AXIS_HINT_KEYS,
   ESTIMATE_AXIS_LABEL_KEYS,
+  estimateBasisLabelKey,
   parseAxisThreshold,
 } from './estimateGating'
 
@@ -42,3 +43,24 @@ describe('estimate axis vocabulary', () => {
     expect(new Set(hints).size).toBe(ESTIMATE_AXES.length)
   })
 })
+
+describe('estimate basis labels', () => {
+  it('labels a stored basis this build knows', () => {
+    expect(estimateBasisLabelKey('predicted')).toBe('inspector.estimate.basis.predicted')
+    expect(estimateBasisLabelKey('observed')).toBe('inspector.estimate.basis.observed')
+  })
+
+  it('reads an ABSENT basis as the forecast it was', () => {
+    // Every estimate written before the vocabulary existed came from the estimator, and those rows
+    // are read back with a plain `JSON.parse`, so the field is genuinely missing rather than
+    // defaulted on the way in.
+    expect(estimateBasisLabelKey(undefined)).toBe('inspector.estimate.basis.predicted')
+  })
+
+  it('says so for a basis this bundle cannot name, instead of guessing', () => {
+    // A browser holds a bundle older than the member it reads. Guessing onto a current member would
+    // relabel a measurement as a forecast with nothing on screen to say so.
+    expect(estimateBasisLabelKey('sampled')).toBe('inspector.estimate.basis.unknown')
+    expect(estimateBasisLabelKey('')).toBe('inspector.estimate.basis.unknown')
+  })
+})

package/app/utils/estimateGating.ts

@@ -1,3 +1,5 @@
+import { isTaskEstimateBasis, type TaskEstimateBasis } from '@cat-factory/contracts'
+
 /**
  * The three axes a `task-estimator` step scores a task on, and the presentation vocabulary every
  * surface that lets a human gate work on them shares.
@@ -58,3 +60,33 @@ export function parseAxisThreshold(raw: string): number | undefined {
   if (!Number.isFinite(parsed)) return undefined
   return Math.min(1, Math.max(0, parsed))
 }
+
+/**
+ * Basis → the label key saying what a stored estimate's scores were formed ON. Three cases, and
+ * they are three because each states a different fact:
+ *
+ *  - ABSENT: a row written before the basis vocabulary existed. Every one of those came from the
+ *    estimator, so calling it a forecast is a fact about the row rather than a default standing in
+ *    for one. `null` is the same case: the field is optional on the schema, but the record travels
+ *    as JSON and an absent value is routinely written back as `null`, so reading that as
+ *    unrecognised would relabel an ordinary old forecast.
+ *  - a member this bundle KNOWS: its own label.
+ *  - anything else: said out loud. `basis` is persisted and read back with no schema pass, and a
+ *    browser holds a bundle older than the member it reads, so guessing onto a current member would
+ *    relabel a measurement as a forecast (or the reverse) with nothing on screen to say so.
+ *
+ * The keys are LITERAL so the typed-message-key check sees them, and the map is exhaustive over the
+ * contracts union, so a third basis fails the typecheck here rather than rendering a raw key.
+ */
+const ESTIMATE_BASIS_LABEL_KEYS: Record<TaskEstimateBasis, string> = {
+  predicted: 'inspector.estimate.basis.predicted',
+  observed: 'inspector.estimate.basis.observed',
+}
+
+const ESTIMATE_BASIS_UNKNOWN_KEY = 'inspector.estimate.basis.unknown'
+
+/** The label key for a stored basis: see {@link ESTIMATE_BASIS_LABEL_KEYS} for the three cases. */
+export function estimateBasisLabelKey(basis: string | null | undefined): string {
+  if (basis === undefined || basis === null) return ESTIMATE_BASIS_LABEL_KEYS.predicted
+  return isTaskEstimateBasis(basis) ? ESTIMATE_BASIS_LABEL_KEYS[basis] : ESTIMATE_BASIS_UNKNOWN_KEY
+}

package/app/utils/pipelineRender.ts

@@ -319,6 +319,8 @@ export function stepSkipReasonKey(step: PipelineStep): string | null {
       return 'pipeline.progress.skipped.producerSkipped'
     case 'run_complete':
       return 'pipeline.progress.skipped.runComplete'
+    case 'no_pull_request':
+      return 'pipeline.progress.skipped.noPullRequest'
     case 'condition':
       return step.stepOptions?.condition?.serviceScope === 'frontend'
         ? 'pipeline.progress.skipped.conditionFrontend'

package/i18n/locales/de.json

@@ -1724,10 +1724,17 @@
     },
     "estimate": {
       "title": "Schätzung",
-      "hint": "Vom Task-Estimator-Agent erzeugt: wie komplex, riskant und wirkungsvoll diese Aufgabe aussieht. Wird verwendet, um zu entscheiden, ob Konsens-Schritte (Mehrfachläufe) sich lohnen.",
+      "hint": "Wie komplex, riskant und wirkungsvoll diese Aufgabe ist. Ein Task Estimator prognostiziert das vor Beginn der Arbeit, ein Task Reassessor misst es danach an der tatsächlich erfolgten Änderung. Wird verwendet, um zu entscheiden, ob Konsens-Schritte (Mehrfachläufe) und andere bedingte Schritte sich lohnen.",
       "complexity": "Komplexität",
       "risk": "Risiko",
-      "impact": "Wirkung"
+      "impact": "Wirkung",
+      "basis": {
+        "predicted": "Prognose vor Beginn der Arbeit",
+        "observed": "Gemessen an der erfolgten Änderung",
+        "unknown": "Von einer anderen App-Version erfasst"
+      },
+      "was": "vorher {value}",
+      "supersededBasis": "Ersetzt: {basis}"
     },
     "reviewTarget": {
       "title": "Geprüfter Pull Request",
@@ -4739,6 +4746,7 @@
         "conditionBackend": "Übersprungen: Diese Aufgabe ändert nur einen Frontend-Dienst, es gibt also keine API dahinter zu prüfen.",
         "producerSkipped": "Übersprungen: Der geprüfte Schritt wurde übersprungen, es gibt nichts zu bewerten.",
         "runComplete": "Übersprungen: Der Lauf endete vor diesem Schritt, es blieb nichts zu tun.",
+        "noPullRequest": "Übersprungen: Dieser Lauf hat keinen Pull Request eröffnet, also gibt es für diesen Schritt keine Änderung zu lesen.",
         "unknown": "Übersprungen: Dieser Schritt wurde nicht ausgeführt."
       }
     },

package/i18n/locales/en.json

@@ -1231,10 +1231,17 @@
     },
     "estimate": {
       "title": "Estimate",
-      "hint": "Produced by the task estimator agent: how complex, risky, and impactful this task looks. Used to decide whether consensus (multi-run) steps are worth running.",
+      "hint": "How complex, risky and impactful this task is. A Task Estimator forecasts it before the work starts; a Task Reassessor measures it afterwards from the change that landed. Used to decide whether consensus (multi-run) steps and other conditional steps are worth running.",
       "complexity": "Complexity",
       "risk": "Risk",
-      "impact": "Impact"
+      "impact": "Impact",
+      "basis": {
+        "predicted": "Forecast before the work started",
+        "observed": "Measured from the change that landed",
+        "unknown": "Recorded by another version of the app"
+      },
+      "was": "was {value}",
+      "supersededBasis": "Replaces: {basis}"
     },
     "reviewTarget": {
       "title": "Under review",
@@ -5391,6 +5398,7 @@
         "conditionBackend": "Skipped: this task changes only a frontend service, so there is no API behind it to exercise.",
         "producerSkipped": "Skipped: the step it reviews was skipped, so there is nothing to grade.",
         "runComplete": "Skipped: the run finished before this step, with nothing left to do.",
+        "noPullRequest": "Skipped: this run opened no pull request, so there is no change for this step to read.",
         "unknown": "Skipped: this step did not run."
       }
     },

package/i18n/locales/es.json

@@ -1138,10 +1138,17 @@
     },
     "estimate": {
       "title": "Estimación",
-      "hint": "Producida por el agente estimador de tareas: cuán compleja, arriesgada e impactante parece esta tarea. Se usa para decidir si merecen la pena los pasos de consenso (multiejecución).",
+      "hint": "Lo compleja, arriesgada e impactante que es esta tarea. Un Task Estimator la pronostica antes de empezar el trabajo y un Task Reassessor la mide después a partir del cambio realizado. Se usa para decidir si merecen la pena los pasos de consenso (multiejecución) y otros pasos condicionales.",
       "complexity": "Complejidad",
       "risk": "Riesgo",
-      "impact": "Impacto"
+      "impact": "Impacto",
+      "basis": {
+        "predicted": "Pronóstico previo al inicio del trabajo",
+        "observed": "Medido a partir del cambio realizado",
+        "unknown": "Registrado por otra versión de la aplicación"
+      },
+      "was": "antes {value}",
+      "supersededBasis": "Reemplaza: {basis}"
     },
     "reviewTarget": {
       "title": "Pull request en revisión",
@@ -5215,6 +5222,7 @@
         "conditionBackend": "Omitido: esta tarea solo modifica un servicio de frontend, así que no hay API detrás que probar.",
         "producerSkipped": "Omitido: el paso que revisa fue omitido, así que no hay nada que evaluar.",
         "runComplete": "Omitido: la ejecución terminó antes de este paso y no quedaba nada que hacer.",
+        "noPullRequest": "Omitido: esta ejecución no abrió ningún pull request, así que este paso no tiene ningún cambio que leer.",
         "unknown": "Omitido: este paso no se ejecutó."
       }
     },

package/i18n/locales/fr.json

@@ -1138,10 +1138,17 @@
     },
     "estimate": {
       "title": "Estimation",
-      "hint": "Produite par l'agent estimateur de tâches : la complexité, le risque et l'impact estimés de cette tâche. Sert à décider si les étapes de consensus (multi-exécutions) en valent la peine.",
+      "hint": "La complexité, le risque et l'impact de cette tâche. Un Task Estimator les prévoit avant le début du travail, un Task Reassessor les mesure ensuite d'après la modification réellement livrée. Sert à décider si les étapes de consensus (multi-exécutions) et les autres étapes conditionnelles en valent la peine.",
       "complexity": "Complexité",
       "risk": "Risque",
-      "impact": "Impact"
+      "impact": "Impact",
+      "basis": {
+        "predicted": "Prévision avant le début du travail",
+        "observed": "Mesuré d'après la modification livrée",
+        "unknown": "Enregistré par une autre version de l'application"
+      },
+      "was": "avant {value}",
+      "supersededBasis": "Remplace : {basis}"
     },
     "reviewTarget": {
       "title": "Pull request en revue",
@@ -5215,6 +5222,7 @@
         "conditionBackend": "Étape ignorée : cette tâche ne modifie qu’un service frontend, il n’y a donc pas d’API derrière à tester.",
         "producerSkipped": "Étape ignorée : l’étape qu’elle relit a été ignorée, il n’y a rien à évaluer.",
         "runComplete": "Étape ignorée : l’exécution s’est terminée avant elle, sans rien à faire.",
+        "noPullRequest": "Étape ignorée : cette exécution n’a ouvert aucune pull request, il n’y a donc aucune modification à lire.",
         "unknown": "Étape ignorée : elle n’a pas été exécutée."
       }
     },

package/i18n/locales/he.json

@@ -1138,10 +1138,17 @@
     },
     "estimate": {
       "title": "הערכה",
-      "hint": "מופק על ידי סוכן הערכת המשימות: עד כמה המשימה נראית מורכבת, מסוכנת ובעלת השפעה. משמש כדי להחליט אם שלבי קונצנזוס (ריבוי הרצות) משתלמים.",
+      "hint": "עד כמה המשימה הזו מורכבת, מסוכנת ומשפיעה. מעריך משימות חוזה זאת לפני תחילת העבודה, וסוכן ההערכה מחדש מודד זאת לאחר מכן מהשינוי שבוצע בפועל. משמש להחלטה אם שלבי קונצנזוס (ריצות מרובות) ושלבים מותנים אחרים שווים את המחיר.",
       "complexity": "מורכבות",
       "risk": "סיכון",
-      "impact": "השפעה"
+      "impact": "השפעה",
+      "basis": {
+        "predicted": "תחזית לפני תחילת העבודה",
+        "observed": "נמדד מהשינוי שבוצע",
+        "unknown": "נרשם בגרסה אחרת של האפליקציה"
+      },
+      "was": "היה {value}",
+      "supersededBasis": "מחליף: {basis}"
     },
     "reviewTarget": {
       "title": "בקשת משיכה בסקירה",
@@ -5215,6 +5222,7 @@
         "conditionBackend": "דולג: המשימה משנה רק שירות צד-לקוח, לכן אין מאחוריו API לבדיקה.",
         "producerSkipped": "דולג: השלב שהוא בודק דולג, לכן אין מה להעריך.",
         "runComplete": "דולג: הריצה הסתיימה לפני השלב הזה, ולא נותר מה לעשות.",
+        "noPullRequest": "דולג: הריצה הזו לא פתחה pull request, ולכן אין לשלב הזה שינוי לקרוא.",
         "unknown": "דולג: השלב הזה לא רץ."
       }
     },

package/i18n/locales/it.json

@@ -1724,10 +1724,17 @@
     },
     "estimate": {
       "title": "Stima",
-      "hint": "Prodotta dall'agente stimatore delle attivita': quanto questa attivita' appare complessa, rischiosa e di impatto. Usata per decidere se vale la pena eseguire i passaggi di consenso (multi-esecuzione).",
+      "hint": "Quanto questa attivita' e' complessa, rischiosa e di impatto. Un Task Estimator la prevede prima che il lavoro inizi, un Task Reassessor la misura dopo, dalla modifica effettivamente realizzata. Usata per decidere se vale la pena eseguire i passaggi di consenso (multi-esecuzione) e gli altri passaggi condizionali.",
       "complexity": "Complessita'",
       "risk": "Rischio",
-      "impact": "Impatto"
+      "impact": "Impatto",
+      "basis": {
+        "predicted": "Previsione prima dell'inizio del lavoro",
+        "observed": "Misurato dalla modifica realizzata",
+        "unknown": "Registrato da un'altra versione dell'app"
+      },
+      "was": "prima {value}",
+      "supersededBasis": "Sostituisce: {basis}"
     },
     "reviewTarget": {
       "title": "Pull request in revisione",
@@ -4739,6 +4746,7 @@
         "conditionBackend": "Saltato: questa attività modifica solo un servizio frontend, quindi non c’è un’API dietro da provare.",
         "producerSkipped": "Saltato: il passo che revisiona è stato saltato, quindi non c’è nulla da valutare.",
         "runComplete": "Saltato: l’esecuzione è terminata prima di questo passo, senza altro da fare.",
+        "noPullRequest": "Saltato: questa esecuzione non ha aperto alcuna pull request, quindi questo passo non ha modifiche da leggere.",
         "unknown": "Saltato: questo passo non è stato eseguito."
       }
     },

package/i18n/locales/ja.json

@@ -1138,10 +1138,17 @@
     },
     "estimate": {
       "title": "見積もり",
-      "hint": "タスク見積もりエージェントが生成: このタスクの複雑さ、リスク、影響の見立てです。コンセンサス (複数実行) ステップを行う価値があるかの判断に使われます。",
+      "hint": "このタスクの複雑さ・リスク・影響度です。Task Estimator が作業開始前に予測し、Task Reassessor が実際に入った変更から事後に測定します。コンセンサス（複数実行）ステップやその他の条件付きステップを実行する価値があるかの判断に使われます。",
       "complexity": "複雑度",
       "risk": "リスク",
-      "impact": "影響度"
+      "impact": "影響度",
+      "basis": {
+        "predicted": "作業開始前の予測",
+        "observed": "実際に入った変更から測定",
+        "unknown": "別のバージョンのアプリが記録"
+      },
+      "was": "以前は {value}",
+      "supersededBasis": "置き換え：{basis}"
     },
     "reviewTarget": {
       "title": "レビュー対象のプルリクエスト",
@@ -5215,6 +5222,7 @@
         "conditionBackend": "スキップ：このタスクはフロントエンドサービスのみを変更するため、背後に検証するAPIがありません。",
         "producerSkipped": "スキップ：レビュー対象のステップがスキップされたため、評価するものがありません。",
         "runComplete": "スキップ：このステップの前に実行が終了し、行う作業が残っていませんでした。",
+        "noPullRequest": "スキップ：この実行はプルリクエストを作成しなかったため、このステップが読み取る変更がありません。",
         "unknown": "スキップ：このステップは実行されませんでした。"
       }
     },

package/i18n/locales/pl.json

@@ -1138,10 +1138,17 @@
     },
     "estimate": {
       "title": "Szacunek",
-      "hint": "Wynik pracy agenta szacującego zadania: jak złożone, ryzykowne i istotne wygląda to zadanie. Służy do decyzji, czy kroki konsensusu (wielokrotne uruchomienia) są opłacalne.",
+      "hint": "Jak złożone, ryzykowne i wpływowe jest to zadanie. Task Estimator prognozuje to przed rozpoczęciem pracy, a Task Reassessor mierzy to później na podstawie faktycznie wprowadzonej zmiany. Służy do decydowania, czy warto uruchamiać kroki konsensusu (wielokrotne przebiegi) i inne kroki warunkowe.",
       "complexity": "Złożoność",
       "risk": "Ryzyko",
-      "impact": "Wpływ"
+      "impact": "Wpływ",
+      "basis": {
+        "predicted": "Prognoza przed rozpoczęciem pracy",
+        "observed": "Zmierzone na podstawie wprowadzonej zmiany",
+        "unknown": "Zapisane przez inną wersję aplikacji"
+      },
+      "was": "wcześniej {value}",
+      "supersededBasis": "Zastępuje: {basis}"
     },
     "reviewTarget": {
       "title": "Przeglądany pull request",
@@ -5215,6 +5222,7 @@
         "conditionBackend": "Pominięto: to zadanie zmienia tylko usługę frontendową, więc nie ma za nią API do sprawdzenia.",
         "producerSkipped": "Pominięto: krok, który ocenia, został pominięty, więc nie ma czego oceniać.",
         "runComplete": "Pominięto: przebieg zakończył się przed tym krokiem, nie było nic do zrobienia.",
+        "noPullRequest": "Pominięto: ten przebieg nie otworzył żadnego pull requesta, więc ten krok nie ma zmiany do przeczytania.",
         "unknown": "Pominięto: ten krok nie został wykonany."
       }
     },

package/i18n/locales/tr.json

@@ -1138,10 +1138,17 @@
     },
     "estimate": {
       "title": "Tahmin",
-      "hint": "Görev tahmin ajanı tarafından üretilir: bu görevin ne kadar karmaşık, riskli ve etkili göründüğü. Konsensüs (çoklu çalıştırma) adımlarının değip değmeyeceğine karar vermek için kullanılır.",
+      "hint": "Bu görevin ne kadar karmaşık, riskli ve etkili olduğu. Görev Tahmincisi işe başlamadan önce öngörür, Görev Yeniden Değerlendiricisi ise sonrasında gerçekte yapılan değişiklikten ölçer. Uzlaşma (çok çalıştırmalı) adımlarının ve diğer koşullu adımların değip değmeyeceğine karar vermek için kullanılır.",
       "complexity": "Karmaşıklık",
       "risk": "Risk",
-      "impact": "Etki"
+      "impact": "Etki",
+      "basis": {
+        "predicted": "İşe başlamadan önceki tahmin",
+        "observed": "Yapılan değişiklikten ölçüldü",
+        "unknown": "Uygulamanın başka bir sürümü kaydetti"
+      },
+      "was": "önceki {value}",
+      "supersededBasis": "Şunu değiştirir: {basis}"
     },
     "reviewTarget": {
       "title": "İncelenen pull request",
@@ -5215,6 +5222,7 @@
         "conditionBackend": "Atlandı: bu görev yalnızca bir frontend servisini değiştiriyor, dolayısıyla arkasında denenecek bir API yok.",
         "producerSkipped": "Atlandı: incelediği adım atlandı, dolayısıyla değerlendirilecek bir şey yok.",
         "runComplete": "Atlandı: çalışma bu adımdan önce sona erdi, yapılacak bir şey kalmadı.",
+        "noPullRequest": "Atlandı: bu çalışma bir pull request açmadı, bu nedenle bu adımın okuyacağı bir değişiklik yok.",
         "unknown": "Atlandı: bu adım çalışmadı."
       }
     },

package/i18n/locales/uk.json

@@ -1138,10 +1138,17 @@
     },
     "estimate": {
       "title": "Оцінка",
-      "hint": "Створюється агентом оцінювання завдань: наскільки складним, ризикованим і впливовим виглядає це завдання. Використовується, щоб вирішити, чи варті кроки консенсусу (кілька запусків).",
+      "hint": "Наскільки складне, ризиковане та впливове це завдання. Task Estimator прогнозує це до початку роботи, а Task Reassessor вимірює це згодом за фактично внесеною зміною. Використовується, щоб вирішити, чи варті кроки консенсусу (кілька запусків) та інші умовні кроки.",
       "complexity": "Складність",
       "risk": "Ризик",
-      "impact": "Вплив"
+      "impact": "Вплив",
+      "basis": {
+        "predicted": "Прогноз до початку роботи",
+        "observed": "Виміряно за внесеною зміною",
+        "unknown": "Записано іншою версією застосунку"
+      },
+      "was": "було {value}",
+      "supersededBasis": "Замінює: {basis}"
     },
     "reviewTarget": {
       "title": "Pull request на огляді",
@@ -5215,6 +5222,7 @@
         "conditionBackend": "Пропущено: це завдання змінює лише фронтенд-сервіс, тож за ним немає API для перевірки.",
         "producerSkipped": "Пропущено: крок, який він перевіряє, був пропущений, тож немає чого оцінювати.",
         "runComplete": "Пропущено: запуск завершився до цього кроку, робити було нічого.",
+        "noPullRequest": "Пропущено: цей запуск не відкрив pull request, тож цьому кроку нічого читати.",
         "unknown": "Пропущено: цей крок не виконувався."
       }
     },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cat-factory/app",
-  "version": "0.282.2",
+  "version": "0.283.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.41",
     "wretch": "^3.0.9",
-    "@cat-factory/contracts": "0.324.0"
+    "@cat-factory/contracts": "0.325.0"
   },
   "devDependencies": {
     "@toad-contracts/testing": "0.3.2",