@cat-factory/app 0.147.1 → 0.147.3

package/app/stores/personalSubscriptions.spec.ts

@@ -1,17 +1,22 @@
 import { describe, it, expect, beforeEach, vi } from 'vitest'
 import { ApiError } from '~/composables/api/errors'
-import { usePersonalSubscriptionsStore } from '~/stores/personalSubscriptions'
+import {
+  personalPasswordCacheKey,
+  usePersonalSubscriptionsStore,
+} from '~/stores/personalSubscriptions'
 
-// The single localStorage key the store caches the personal password under (private to the
-// store; hard-coded here so the buffer/expiry semantics can be asserted directly).
-const CACHE_KEY = 'cf.personal-pw'
+// The scoped localStorage key the store caches under, for the stubbed apiBase ('') + user
+// (null → 'anon') the default test setup provides (see test/setup.ts). ADR 0026 D7.
+const CACHE_KEY = personalPasswordCacheKey('', null)
+/** The retired pre-scoping global key. */
+const LEGACY_CACHE_KEY = 'cf.personal-pw'
 const HOUR = 60 * 60 * 1000
 /** Mirrors PASSWORD_EXPIRY_BUFFER_MS in the store — the runway a key must have to be ridden. */
 const BUFFER_MS = 8 * HOUR
 
 /** Write a cache entry with an explicit remaining lifetime (positive = valid, negative = past). */
-function seedCache(password: string, msFromNow: number) {
-  localStorage.setItem(CACHE_KEY, JSON.stringify({ password, expiresAt: Date.now() + msFromNow }))
+function seedCache(password: string, msFromNow: number, key = CACHE_KEY) {
+  localStorage.setItem(key, JSON.stringify({ password, expiresAt: Date.now() + msFromNow }))
 }
 
 /** A 428 credential_required error shaped like the server envelope the store parses. */
@@ -61,6 +66,52 @@ describe('personal-password cache expiry buffer', () => {
   })
 })
 
+// ADR 0026 D7: the cache is scoped per installation (apiBase) + user, and the retired global
+// `cf.personal-pw` key is purged on sight and never reused.
+describe('per-installation + per-user cache scoping', () => {
+  beforeEach(() => {
+    localStorage.clear()
+  })
+
+  it('derives distinct keys per installation and per user', () => {
+    // Same origin, different installations (apiBase) → different keys.
+    expect(personalPasswordCacheKey('https://a.example', 'usr_1')).not.toBe(
+      personalPasswordCacheKey('https://b.example', 'usr_1'),
+    )
+    // Same installation, different users → different keys.
+    expect(personalPasswordCacheKey('https://a.example', 'usr_1')).not.toBe(
+      personalPasswordCacheKey('https://a.example', 'usr_2'),
+    )
+    // A missing user id collapses to a stable `anon` segment (auth disabled).
+    expect(personalPasswordCacheKey('https://a.example', null)).toBe(
+      personalPasswordCacheKey('https://a.example', undefined),
+    )
+  })
+
+  it('does NOT read another installation/user cache entry', () => {
+    const store = usePersonalSubscriptionsStore()
+    // A healthy entry belonging to a DIFFERENT scope must be invisible to this store.
+    seedCache('other-secret', 40 * HOUR, personalPasswordCacheKey('https://other', 'usr_x'))
+    expect(store.getCachedPassword()).toBeUndefined()
+  })
+
+  it('purges the retired global `cf.personal-pw` key on read and never reuses it', () => {
+    const store = usePersonalSubscriptionsStore()
+    seedCache('legacy-secret', 40 * HOUR, LEGACY_CACHE_KEY)
+    // The legacy value is not offered (the scoped key is absent)…
+    expect(store.getCachedPassword()).toBeUndefined()
+    // …and the retired global key is removed so it can't be reused across installs/users.
+    expect(localStorage.getItem(LEGACY_CACHE_KEY)).toBeNull()
+  })
+
+  it('round-trips a password under the scoped key', () => {
+    const store = usePersonalSubscriptionsStore()
+    seedCache('mine', 40 * HOUR)
+    expect(store.getCachedPassword()).toBe('mine')
+    expect(localStorage.getItem(CACHE_KEY)).not.toBeNull()
+  })
+})
+
 describe('withCredential early re-entry', () => {
   beforeEach(() => {
     localStorage.clear()

package/app/stores/personalSubscriptions.ts

@@ -12,12 +12,22 @@ import type {
 // a personal PASSWORD. The token itself is double-encrypted server-side and never returned;
 // this store only carries metadata + the renewal warning.
 //
-// To keep the password mostly transparent, it is cached CLIENT-SIDE in localStorage under a
-// SINGLE key with a TTL: the backend gate applies one password to ALL of a run's
-// individual-usage vendors, so there's no point keying the cache per vendor. A task
-// start/retry (and each interaction with a live run) rides along with the cached password —
-// sent as the `X-Personal-Password` header — and the user is only re-prompted once it
-// expires (or is wrong).
+// To keep the password mostly transparent, it is cached CLIENT-SIDE in localStorage with a
+// TTL: the backend gate applies one password to ALL of a run's individual-usage vendors, so
+// there's no point keying the cache per vendor. A task start/retry (and each interaction with a
+// live run) rides along with the cached password — sent as the `X-Personal-Password` header —
+// and the user is only re-prompted once it expires (or is wrong).
+//
+// The cache key is scoped PER INSTALLATION and PER USER (ADR 0026 D7): `cf.personal-pw:<hash of
+// the configured API base>:<user id>`. The bare `cf.personal-pw` it replaced was keyed only by
+// browser origin, so on a shared origin (two local installs on localhost, or one hosted origin
+// fronting several deployments) one installation's cached password was offered to another as
+// `X-Personal-Password`, and a second signed-in user on a shared browser profile inherited the
+// first user's password. Keying on the API base (distinct per installation even when the origin
+// is shared) and the user id closes both: another installation or user sees no cache and is
+// challenged normally. Per-workspace scoping is NOT added — the password is a per-user secret
+// (the backend applies one to all of a run's individual-usage vendors), so it would only add
+// redundant prompts.
 //
 // Every gated action (start / retry / confirm) re-validates the cache against an 8h EXPIRY
 // BUFFER: a key with less than that runway left is withheld (treated as absent) so the
@@ -43,7 +53,37 @@ const PASSWORD_TTL_MS = 40 * 60 * 60 * 1000
  * EARLY — a buffer wide enough that a pipeline kicked off now won't outlive the key (8h).
  */
 const PASSWORD_EXPIRY_BUFFER_MS = 8 * 60 * 60 * 1000
-const CACHE_KEY = 'cf.personal-pw'
+
+/** Prefix for the per-installation + per-user cache key (see the file header). */
+const CACHE_KEY_PREFIX = 'cf.personal-pw'
+/**
+ * The pre-scoping GLOBAL key (origin-only), retired by ADR 0026 D7. It is purged on sight and
+ * its value is NEVER reused — migrating it would re-introduce exactly the cross-installation /
+ * cross-user reuse the scoping removes, so the affected user is simply re-challenged once.
+ */
+const LEGACY_CACHE_KEY = 'cf.personal-pw'
+
+/** A short, stable non-cryptographic hash (FNV-1a → base36) of the API base, for the key scope. */
+function scopeHash(input: string): string {
+  let h = 0x811c9dc5
+  for (let i = 0; i < input.length; i++) {
+    h ^= input.charCodeAt(i)
+    h = Math.imul(h, 0x01000193)
+  }
+  return (h >>> 0).toString(36)
+}
+
+/**
+ * The localStorage key the personal password is cached under, scoped per installation (the
+ * configured `apiBase`, hashed) and per user (`userId`, or `anon` when auth is off / nobody is
+ * signed in). Exported for the store's unit test to seed/read the exact key the store uses.
+ */
+export function personalPasswordCacheKey(
+  apiBase: string,
+  userId: string | null | undefined,
+): string {
+  return `${CACHE_KEY_PREFIX}:${scopeHash(apiBase)}:${userId ?? 'anon'}`
+}
 
 /** A credential prompt the UI must satisfy (set when the server replies 428). */
 export interface PendingCredential {
@@ -71,6 +111,14 @@ export function parseCredentialError(
 
 export const usePersonalSubscriptionsStore = defineStore('personalSubscriptions', () => {
   const api = useApi()
+  const auth = useAuthStore()
+  // The configured API base is a static per-installation fact, so hash it once at setup; the user
+  // id is dynamic, so it is read lazily off the auth store when the key is computed.
+  const apiBase = String(useRuntimeConfig().public.apiBase ?? '')
+  /** The current per-installation + per-user cache key. */
+  function cacheKey(): string {
+    return personalPasswordCacheKey(apiBase, auth.user?.id)
+  }
   const subscriptions = ref<PersonalSubscriptionStatus[]>([])
   const loading = ref(false)
   /** When set, a credential modal should open to satisfy the pending prompt. */
@@ -119,12 +167,15 @@ export const usePersonalSubscriptionsStore = defineStore('personalSubscriptions'
    */
   function getCachedPassword(bufferMs = 0): string | undefined {
     if (typeof localStorage === 'undefined') return undefined
+    // Retire the pre-scoping global key on sight (never reused — see LEGACY_CACHE_KEY).
+    purgeLegacyCache()
     try {
-      const raw = localStorage.getItem(CACHE_KEY)
+      const key = cacheKey()
+      const raw = localStorage.getItem(key)
       if (!raw) return undefined
       const { password, expiresAt } = JSON.parse(raw) as { password: string; expiresAt: number }
       if (Date.now() > expiresAt) {
-        localStorage.removeItem(CACHE_KEY)
+        localStorage.removeItem(key)
         return undefined
       }
       // Within the buffer the key is still valid — keep it, but withhold it so the action
@@ -140,7 +191,7 @@ export const usePersonalSubscriptionsStore = defineStore('personalSubscriptions'
     if (typeof localStorage === 'undefined') return
     try {
       localStorage.setItem(
-        CACHE_KEY,
+        cacheKey(),
         JSON.stringify({ password, expiresAt: Date.now() + PASSWORD_TTL_MS }),
       )
     } catch {
@@ -151,7 +202,17 @@ export const usePersonalSubscriptionsStore = defineStore('personalSubscriptions'
   function clearCachedPassword() {
     if (typeof localStorage === 'undefined') return
     try {
-      localStorage.removeItem(CACHE_KEY)
+      localStorage.removeItem(cacheKey())
+    } catch {
+      // best-effort
+    }
+  }
+
+  /** Remove the retired global `cf.personal-pw` key so its value can never be offered again. */
+  function purgeLegacyCache() {
+    if (typeof localStorage === 'undefined') return
+    try {
+      localStorage.removeItem(LEGACY_CACHE_KEY)
     } catch {
       // best-effort
     }

package/app/utils/prReviewProgress.spec.ts

@@ -1,6 +1,11 @@
 import { describe, it, expect } from 'vitest'
-import type { StepSubtasks } from '~/types/execution'
-import { activeChunkLabels, chunkReviewPercent, isSlicingChunks } from './prReviewProgress'
+import type { PrReviewStepState, StepSubtasks } from '~/types/execution'
+import {
+  activeChunkLabels,
+  chunkReviewPercent,
+  hasNoSlicePlan,
+  prReviewPhase,
+} from './prReviewProgress'
 
 const subtasks = (over: Partial<StepSubtasks>): StepSubtasks => ({
   completed: 0,
@@ -9,18 +14,19 @@ const subtasks = (over: Partial<StepSubtasks>): StepSubtasks => ({
   ...over,
 })
 
-describe('isSlicingChunks', () => {
-  it('is slicing when there is no todo list yet (null/undefined or empty)', () => {
-    // No plan committed → the reviewer is still grouping the diff into chunks.
-    expect(isSlicingChunks(null)).toBe(true)
-    expect(isSlicingChunks(undefined)).toBe(true)
-    expect(isSlicingChunks(subtasks({ total: 0 }))).toBe(true)
+describe('hasNoSlicePlan', () => {
+  it('has no plan when there is no todo list yet (null/undefined or empty)', () => {
+    // No per-slice plan reported — a NEUTRAL signal (grouping, OR a subagent review that never
+    // writes a parent plan), NOT proof of "slicing".
+    expect(hasNoSlicePlan(null)).toBe(true)
+    expect(hasNoSlicePlan(undefined)).toBe(true)
+    expect(hasNoSlicePlan(subtasks({ total: 0 }))).toBe(true)
   })
 
-  it('is not slicing once the todo list exists (slicing is done)', () => {
-    expect(isSlicingChunks(subtasks({ total: 3, completed: 1 }))).toBe(false)
-    // A single-chunk plan still counts as sliced — a plan of size 1 is a committed plan.
-    expect(isSlicingChunks(subtasks({ total: 1 }))).toBe(false)
+  it('has a plan once the todo list exists', () => {
+    expect(hasNoSlicePlan(subtasks({ total: 3, completed: 1 }))).toBe(false)
+    // A single-slice plan still counts — a plan of size 1 is a committed plan.
+    expect(hasNoSlicePlan(subtasks({ total: 1 }))).toBe(false)
   })
 })
 
@@ -71,3 +77,48 @@ describe('activeChunkLabels', () => {
     ).toEqual([])
   })
 })
+
+// `prReviewPhase` reads only `status`; the other PrReviewStepState fields are irrelevant here.
+const state = (status: PrReviewStepState['status']): PrReviewStepState =>
+  ({ status }) as PrReviewStepState
+
+describe('prReviewPhase', () => {
+  it('is null with no live review or a terminal/passed-through status', () => {
+    expect(prReviewPhase(null, null)).toBeNull()
+    expect(prReviewPhase(undefined, subtasks({ total: 3, completed: 3 }))).toBeNull()
+    expect(prReviewPhase(state('done'), subtasks({ total: 3, completed: 3 }))).toBeNull()
+    expect(prReviewPhase(state('skipped'), null)).toBeNull()
+  })
+
+  it('is the neutral `planning` kind while reviewing with no todo list yet (counts zeroed)', () => {
+    // No plan reported → surface a neutral "reviewing, planning" phase (NOT "slicing") and don't
+    // leak a misleading 0/0 slice count.
+    expect(prReviewPhase(state('reviewing'), null)).toEqual({
+      kind: 'planning',
+      completed: 0,
+      total: 0,
+    })
+    expect(prReviewPhase(state('reviewing'), subtasks({ total: 0 }))).toEqual({
+      kind: 'planning',
+      completed: 0,
+      total: 0,
+    })
+  })
+
+  it('is reviewing with the slice counts once the todo list exists', () => {
+    expect(prReviewPhase(state('reviewing'), subtasks({ total: 4, completed: 1 }))).toEqual({
+      kind: 'reviewing',
+      completed: 1,
+      total: 4,
+    })
+  })
+
+  it('maps the parked / resolving statuses to their phase', () => {
+    expect(
+      prReviewPhase(state('awaiting_selection'), subtasks({ total: 4, completed: 4 }))?.kind,
+    ).toBe('awaiting')
+    expect(prReviewPhase(state('challenging'), null)?.kind).toBe('challenging')
+    expect(prReviewPhase(state('fixing'), null)?.kind).toBe('fixing')
+    expect(prReviewPhase(state('posting'), null)?.kind).toBe('posting')
+  })
+})

package/app/utils/prReviewProgress.ts

@@ -1,16 +1,23 @@
-import type { StepSubtasks } from '~/types/execution'
+import type { PrReviewStepState, StepSubtasks } from '~/types/execution'
 
 // Pure derivation of the PR deep-reviewer's `reviewing`-phase progress, factored out of
 // `PrReviewWindow.vue` so it is unit-testable independently of the Vue component.
 //
-// The reviewer maintains a per-slice todo list (`step.subtasks`) once it has grouped the diff
-// into cohesive chunks. The PRESENCE of that list is the signal that slicing is done, so the two
-// `reviewing` sub-phases are told apart by it:
-//   - no todo list yet (`total === 0`) → still SLICING the diff into chunks (no plan committed).
-//   - todo list present (`total > 0`) → slicing DONE, working through the chunks.
+// When the reviewer maintains a per-slice todo list (`step.subtasks`) — one entry per cohesive
+// chunk of the diff — the UI shows per-slice progress. But that list is NOT always present: the
+// reviewer often reviews via parallel general-purpose subagents, which never write a parent-level
+// TodoWrite plan, so `subtasks` stays empty for the whole review (ADR 0026 P2/D2.2). So an empty
+// todo list is NOT proof the reviewer is "still slicing" — it only means no per-slice plan has
+// been reported yet. We therefore surface a NEUTRAL "reviewing, planning slices" state and switch
+// to per-slice status the moment a plan exists — the UI never asserts a specific "slicing" phase
+// purely because the parent stream emitted no todo list.
 
-/** True while the reviewer is still grouping the diff into chunks (it has not committed a plan). */
-export function isSlicingChunks(subtasks: StepSubtasks | null | undefined): boolean {
+/**
+ * True while NO per-slice todo plan has been reported (`total <= 0`). This is a neutral
+ * "no plan yet" signal — the reviewer may be grouping the diff OR reviewing via subagents that
+ * don't write a parent plan — NOT an assertion that it is "still slicing" (see the note above).
+ */
+export function hasNoSlicePlan(subtasks: StepSubtasks | null | undefined): boolean {
   return (subtasks?.total ?? 0) <= 0
 }
 
@@ -26,3 +33,58 @@ export function chunkReviewPercent(subtasks: StepSubtasks | null | undefined): n
 export function activeChunkLabels(subtasks: StepSubtasks | null | undefined): string[] {
   return subtasks?.items?.filter((i) => i.status === 'in_progress').map((i) => i.label) ?? []
 }
+
+/**
+ * The at-a-glance phase of a `pr-reviewer` step, collapsing its `prReview.status` (+ the
+ * has-a-plan signal from the todo list) into a single kind the board surfaces label without
+ * re-deriving. `completed`/`total` carry the slice counts for the `reviewing` kind. The
+ * `planning` kind is the NEUTRAL "reviewing, no per-slice plan reported yet" state (see
+ * {@link hasNoSlicePlan}) — it deliberately does NOT claim a specific "slicing" phase, since an
+ * empty todo list is the normal shape of a subagent-driven review, not proof of slicing.
+ * Returns `null` for the terminal / passed-through states (`done`/`skipped`) and when there is
+ * no live review — those have no in-flight phase to show.
+ */
+export type PrReviewPhaseKind =
+  | 'planning'
+  | 'reviewing'
+  | 'awaiting'
+  | 'challenging'
+  | 'fixing'
+  | 'posting'
+
+export interface PrReviewPhase {
+  kind: PrReviewPhaseKind
+  /** Slices whose review is finished (0 while planning). */
+  completed: number
+  /** Total slices the reviewer grouped the diff into (0 while planning). */
+  total: number
+}
+
+export function prReviewPhase(
+  state: PrReviewStepState | null | undefined,
+  subtasks: StepSubtasks | null | undefined,
+): PrReviewPhase | null {
+  const status = state?.status
+  if (!status) return null
+  const completed = subtasks?.completed ?? 0
+  const total = subtasks?.total ?? 0
+  switch (status) {
+    case 'reviewing':
+      // No per-slice plan reported yet ⇒ neutral "planning" (don't claim "slicing"); once a plan
+      // exists, work through the chunks with live counts.
+      return hasNoSlicePlan(subtasks)
+        ? { kind: 'planning', completed: 0, total: 0 }
+        : { kind: 'reviewing', completed, total }
+    case 'awaiting_selection':
+      return { kind: 'awaiting', completed, total }
+    case 'challenging':
+      return { kind: 'challenging', completed, total }
+    case 'fixing':
+      return { kind: 'fixing', completed, total }
+    case 'posting':
+      return { kind: 'posting', completed, total }
+    default:
+      // done / skipped — no live phase to surface.
+      return null
+  }
+}

package/i18n/locales/de.json

@@ -4943,9 +4943,9 @@
     "suggestedFix": "Lösungsvorschlag:",
     "line": "Zeile {line}",
     "reviewing": {
-      "slicing": {
-        "title": "Diff wird in Abschnitte zerlegt…",
-        "hint": "Die geänderten Dateien werden in zusammenhängende Abschnitte gruppiert, damit jeder einzeln geprüft werden kann. Die Abschnittsliste erscheint hier, sobald die Zerlegung abgeschlossen ist."
+      "planning": {
+        "title": "Pull Request wird geprüft…",
+        "hint": "Der Prüfer arbeitet den Diff durch. Der Fortschritt pro Abschnitt erscheint hier, sobald die Änderungen in Abschnitte gruppiert werden."
       },
       "reviewingChunks": {
         "title": "Abschnitte werden geprüft…",
@@ -4961,6 +4961,14 @@
         "pending": "In Warteschlange"
       }
     },
+    "phase": {
+      "planning": "Wird geprüft…",
+      "reviewing": "Prüfe {completed}/{total} Abschnitte",
+      "awaiting": "Ergebnisse bereit",
+      "challenging": "Wird untersucht…",
+      "fixing": "Wird behoben…",
+      "posting": "Wird veröffentlicht…"
+    },
     "challenge": {
       "action": "Anfechten",
       "reChallenge": "Erneut anfechten",

package/i18n/locales/en.json

@@ -5072,9 +5072,9 @@
     "suggestedFix": "Suggested fix:",
     "line": "line {line}",
     "reviewing": {
-      "slicing": {
-        "title": "Slicing the diff into chunks…",
-        "hint": "Grouping the changed files into cohesive chunks so each can be reviewed on its own. The chunk list appears here once slicing is done."
+      "planning": {
+        "title": "Reviewing the pull request…",
+        "hint": "The reviewer is working through the diff. Per-slice progress appears here once it groups the changes into slices."
       },
       "reviewingChunks": {
         "title": "Reviewing the chunks…",
@@ -5090,6 +5090,14 @@
         "pending": "Queued"
       }
     },
+    "phase": {
+      "planning": "Reviewing…",
+      "reviewing": "Reviewing {completed}/{total} slices",
+      "awaiting": "Findings ready",
+      "challenging": "Investigating…",
+      "fixing": "Fixing…",
+      "posting": "Posting…"
+    },
     "challenge": {
       "action": "Challenge",
       "reChallenge": "Challenge again",

package/i18n/locales/es.json

@@ -4931,9 +4931,9 @@
     "suggestedFix": "Corrección sugerida:",
     "line": "línea {line}",
     "reviewing": {
-      "slicing": {
-        "title": "Dividiendo el diff en fragmentos…",
-        "hint": "Agrupando los archivos modificados en fragmentos coherentes para revisar cada uno por separado. La lista de fragmentos aparecerá aquí cuando termine la división."
+      "planning": {
+        "title": "Revisando la pull request…",
+        "hint": "El revisor está analizando el diff. El progreso por sección aparecerá aquí cuando agrupe los cambios en secciones."
       },
       "reviewingChunks": {
         "title": "Revisando los fragmentos…",
@@ -4949,6 +4949,14 @@
         "pending": "En cola"
       }
     },
+    "phase": {
+      "planning": "Revisando…",
+      "reviewing": "Revisando {completed}/{total} secciones",
+      "awaiting": "Resultados listos",
+      "challenging": "Investigando…",
+      "fixing": "Corrigiendo…",
+      "posting": "Publicando…"
+    },
     "challenge": {
       "action": "Cuestionar",
       "reChallenge": "Cuestionar de nuevo",

package/i18n/locales/fr.json

@@ -4931,9 +4931,9 @@
     "suggestedFix": "Correction suggérée :",
     "line": "ligne {line}",
     "reviewing": {
-      "slicing": {
-        "title": "Découpage du diff en sections…",
-        "hint": "Regroupement des fichiers modifiés en sections cohérentes afin de pouvoir examiner chacune séparément. La liste des sections apparaîtra ici une fois le découpage terminé."
+      "planning": {
+        "title": "Révision de la pull request…",
+        "hint": "Le relecteur parcourt le diff. La progression par section apparaîtra ici une fois les modifications regroupées en sections."
       },
       "reviewingChunks": {
         "title": "Revue des sections…",
@@ -4949,6 +4949,14 @@
         "pending": "En attente"
       }
     },
+    "phase": {
+      "planning": "Révision…",
+      "reviewing": "Révision {completed}/{total} sections",
+      "awaiting": "Résultats prêts",
+      "challenging": "Analyse en cours…",
+      "fixing": "Correction…",
+      "posting": "Publication…"
+    },
     "challenge": {
       "action": "Contester",
       "reChallenge": "Contester à nouveau",

package/i18n/locales/he.json

@@ -4942,9 +4942,9 @@
     "suggestedFix": "תיקון מוצע:",
     "line": "שורה {line}",
     "reviewing": {
-      "slicing": {
-        "title": "מחלק את ההבדלים למקטעים…",
-        "hint": "מקבץ את הקבצים שהשתנו למקטעים לכידים כדי לבדוק כל אחד בנפרד. רשימת המקטעים תופיע כאן לאחר סיום החלוקה."
+      "planning": {
+        "title": "בודק את בקשת המשיכה…",
+        "hint": "הבודק עובר על ההבדלים. ההתקדמות לפי מקטע תופיע כאן לאחר שהשינויים יקובצו למקטעים."
       },
       "reviewingChunks": {
         "title": "בודק את המקטעים…",
@@ -4960,6 +4960,14 @@
         "pending": "בתור"
       }
     },
+    "phase": {
+      "planning": "בודק…",
+      "reviewing": "בודק {completed}/{total} מקטעים",
+      "awaiting": "הממצאים מוכנים",
+      "challenging": "חוקר…",
+      "fixing": "מתקן…",
+      "posting": "מפרסם…"
+    },
     "challenge": {
       "action": "ערער",
       "reChallenge": "ערער שוב",

package/i18n/locales/it.json

@@ -4943,9 +4943,9 @@
     "suggestedFix": "Correzione suggerita:",
     "line": "riga {line}",
     "reviewing": {
-      "slicing": {
-        "title": "Suddivisione del diff in blocchi…",
-        "hint": "Raggruppamento dei file modificati in blocchi coerenti per esaminare ciascuno separatamente. L'elenco dei blocchi comparirà qui al termine della suddivisione."
+      "planning": {
+        "title": "Revisione della pull request…",
+        "hint": "Il revisore sta esaminando il diff. L'avanzamento per sezione comparirà qui una volta raggruppate le modifiche in sezioni."
       },
       "reviewingChunks": {
         "title": "Revisione dei blocchi…",
@@ -4961,6 +4961,14 @@
         "pending": "In coda"
       }
     },
+    "phase": {
+      "planning": "Revisione…",
+      "reviewing": "Revisione {completed}/{total} sezioni",
+      "awaiting": "Risultati pronti",
+      "challenging": "Analisi in corso…",
+      "fixing": "Correzione…",
+      "posting": "Pubblicazione…"
+    },
     "challenge": {
       "action": "Contesta",
       "reChallenge": "Contesta di nuovo",

package/i18n/locales/ja.json

@@ -4943,9 +4943,9 @@
     "suggestedFix": "修正案:",
     "line": "{line}行目",
     "reviewing": {
-      "slicing": {
-        "title": "差分をチャンクに分割中…",
-        "hint": "変更されたファイルをまとまりのあるチャンクにグループ化し、各チャンクを個別にレビューできるようにしています。分割が完了すると、ここにチャンク一覧が表示されます。"
+      "planning": {
+        "title": "プルリクエストをレビュー中…",
+        "hint": "レビュー担当者が差分を確認しています。変更が区分にグループ化されると、区分ごとの進捗がここに表示されます。"
       },
       "reviewingChunks": {
         "title": "チャンクをレビュー中…",
@@ -4961,6 +4961,14 @@
         "pending": "待機中"
       }
     },
+    "phase": {
+      "planning": "レビュー中…",
+      "reviewing": "レビュー中 {completed}/{total} 区分",
+      "awaiting": "指摘の準備完了",
+      "challenging": "調査中…",
+      "fixing": "修正中…",
+      "posting": "投稿中…"
+    },
     "challenge": {
       "action": "異議を唱える",
       "reChallenge": "再度異議を唱える",

package/i18n/locales/pl.json

@@ -4931,9 +4931,9 @@
     "suggestedFix": "Sugerowana poprawka:",
     "line": "wiersz {line}",
     "reviewing": {
-      "slicing": {
-        "title": "Dzielenie zmian na fragmenty…",
-        "hint": "Grupowanie zmienionych plików w spójne fragmenty, aby każdy można było przejrzeć osobno. Lista fragmentów pojawi się tutaj po zakończeniu podziału."
+      "planning": {
+        "title": "Przeglądanie pull requesta…",
+        "hint": "Recenzent analizuje zmiany. Postęp poszczególnych fragmentów pojawi się tutaj po pogrupowaniu zmian we fragmenty."
       },
       "reviewingChunks": {
         "title": "Przeglądanie fragmentów…",
@@ -4949,6 +4949,14 @@
         "pending": "W kolejce"
       }
     },
+    "phase": {
+      "planning": "Przegląd…",
+      "reviewing": "Przegląd {completed}/{total} fragmentów",
+      "awaiting": "Wyniki gotowe",
+      "challenging": "Analizowanie…",
+      "fixing": "Naprawianie…",
+      "posting": "Publikowanie…"
+    },
     "challenge": {
       "action": "Zakwestionuj",
       "reChallenge": "Zakwestionuj ponownie",