@cat-factory/app 0.179.0 → 0.180.0

package/app/components/initiative/InitiativePlanningWindow.vue

@@ -10,16 +10,25 @@
 // (`ui.openInitiativePlanning`) or as the interviewer step's result view. Live `initiative`
 // stream events patch the store, so an open window follows the interview as it progresses.
 //
+// An interview runs over MULTIPLE ROUNDS and the entity keeps the settled ones, so the list is a
+// mix of what the human still owes an answer and what they already dealt with. It renders pending
+// first (`orderInterviewQuestions`) — see the `order` snapshot below for why that is recomputed per
+// round rather than live.
+//
 // CONTINUE/PROCEED ARE ASYNC. They only record the intent on the parked step and wake the durable
 // driver; the interviewer LLM then runs for as long as it takes, and the response carries the
 // PRE-resume entity. So the window must not key its body on the entity alone — that renders
 // identically before and after the click, which reads as the button having done nothing. The
 // phase below folds the planning RUN's status in, so the wait is visible and a failed pass says
 // so instead of leaving the human staring at questions they already submitted.
-import { computed, reactive, watch } from 'vue'
+import { computed, reactive, ref, watch } from 'vue'
 import ClarificationItem from '~/components/common/ClarificationItem.vue'
 import InterviewGateNotice from '~/components/common/InterviewGateNotice.vue'
-import { INITIATIVE_STATUS_LABEL_KEYS } from '~/utils/initiative'
+import {
+  INITIATIVE_STATUS_LABEL_KEYS,
+  isPendingQuestion,
+  orderInterviewQuestions,
+} from '~/utils/initiative'
 import { interviewGatePhase } from '~/utils/interviewGate'
 import ResultWindowShell from '~/components/panels/ResultWindowShell.vue'
 
@@ -41,9 +50,7 @@ const questions = computed(() =>
   (initiative.value?.qa ?? []).map((q, i) => ({ ...q, key: q.id ?? `q-${i}` })),
 )
 /** Questions still needing an answer: not dismissed, and not yet answered (mirrors backend). */
-const pending = computed(() =>
-  questions.value.filter((q) => q.status !== 'dismissed' && !(q.answer ?? '').trim()),
-)
+const pending = computed(() => questions.value.filter(isPendingQuestion))
 
 // Per-question answer drafts, seeded from the entity and refreshed as new rounds arrive
 // without clobbering an answer the human is mid-edit on.
@@ -58,6 +65,28 @@ watch(
   { immediate: true },
 )
 
+/**
+ * Render order (pending first — see `orderInterviewQuestions`), re-snapshotted ONLY when the
+ * question SET changes, i.e. when a round lands. Deriving it live from the answers instead would
+ * yank a question out from under the human the moment they blurred its textarea and shuffle
+ * everything below it up, while they are reading down the list. Re-snapshotting per ROUND rather
+ * than per question is what keeps a window left open across rounds correct: a question answered in
+ * round one has to sink below round two's new ones, which a rank frozen at first sight never would.
+ */
+const order = ref<string[]>([])
+watch(
+  () => questions.value.map((q) => q.key).join('|'),
+  () => {
+    order.value = orderInterviewQuestions(questions.value).map((q) => q.key)
+  },
+  { immediate: true },
+)
+const orderedQuestions = computed(() => {
+  const rank = new Map(order.value.map((key, i) => [key, i]))
+  // A question the snapshot has not seen is by definition new, so it is pending and sorts first.
+  return [...questions.value].sort((a, b) => (rank.get(a.key) ?? -1) - (rank.get(b.key) ?? -1))
+})
+
 const resuming = computed(() => initiatives.resuming)
 
 /**
@@ -221,7 +250,7 @@ async function onDiscard() {
         <!-- Interview questions — the shared clarification surface (answer / not-relevant /
                  recommend), reused with the requirements-review window. -->
         <ul v-else class="space-y-4">
-          <li v-for="q in questions" :key="q.key" data-testid="initiative-planning-question">
+          <li v-for="q in orderedQuestions" :key="q.key" data-testid="initiative-planning-question">
             <ClarificationItem
               v-model:answer="drafts[q.key]"
               :prompt="q.question"

package/app/components/tasks/BugHuntModal.vue

@@ -10,6 +10,13 @@
 // unavailable or failed still shows its candidates (flagged as unassessed, since the scan is
 // useful on its own), and a scan that hit its cap says so — a silently shortened list reads
 // exactly like an exhaustive one.
+//
+// The tracker selector doubles as the "add a tracker" affordance (the same two-tier menu
+// `<ContextIssuePicker>` renders, off the shared `buildSourceChoices`): a hunt is a common
+// place to find out the tracker holding the bugs isn't connected here yet, and the answer
+// has to be a route to that tracker's own connect screen rather than "go find the
+// Integrations hub". The connect modal opens OVER the hunt, so nothing typed here is lost.
+import type { DropdownMenuItem } from '@nuxt/ui'
 import type { TaskSourceReadReason } from '@cat-factory/contracts'
 import type {
   BugHuntAnalysisStatus,
@@ -17,6 +24,7 @@ import type {
   BugHuntConfidence,
   TaskSourceKind,
 } from '~/types/domain'
+import { type SourceChoice, buildSourceChoices, reconcileSource } from '~/utils/taskSources'
 import IntegrationBackTitle from '~/components/layout/IntegrationBackTitle.vue'
 
 const { t, d, n } = useI18n()
@@ -54,8 +62,64 @@ const containerItems = computed(() =>
     })),
 )
 
-const sourceItems = computed(() =>
-  tasks.offeredSources.map((s) => ({ label: s.label, value: s.source })),
+const descriptor = computed(() => (source.value ? tasks.descriptorFor(source.value) : undefined))
+
+// Two-tier tracker menu: pick one the workspace already offers, or add one it doesn't.
+const sourceChoices = computed(() => buildSourceChoices(tasks.sources, source.value))
+const sourceMenu = computed<DropdownMenuItem[][]>(() =>
+  sourceChoices.value.map((group) =>
+    group.map((choice) =>
+      choice.action === 'select'
+        ? {
+            label: choice.label,
+            icon: choice.icon,
+            trailingIcon: choice.active ? 'i-lucide-check' : undefined,
+            onSelect: () => {
+              source.value = choice.source
+            },
+          }
+        : {
+            label: addLabel(choice),
+            icon: 'i-lucide-plug',
+            onSelect: () => addSource(choice.source),
+          },
+    ),
+  ),
+)
+
+/** The trackers that can be added — the empty state's buttons, where none is offered yet. */
+const addableSources = computed(() =>
+  sourceChoices.value.flat().filter((c) => c.action !== 'select'),
+)
+
+/**
+ * Wording for an addable tracker: `enable` is connected but toggled off for this workspace,
+ * so the user is never told to "connect" something they already connected.
+ */
+function addLabel(choice: SourceChoice): string {
+  return choice.action === 'enable'
+    ? t('bugHunt.enableSource', { label: choice.label })
+    : t('bugHunt.connectSource', { label: choice.label })
+}
+
+/**
+ * The tracker the user left to add, so it becomes the selection the moment it turns up
+ * offered (the connect modal re-probes on success and this hunt stays open underneath it).
+ * Also the reconcile trigger for a source that STOPS being offered — disconnected, or
+ * toggled off in settings while the hunt sat open.
+ */
+const awaitingConnect = ref<TaskSourceKind | null>(null)
+function addSource(s: TaskSourceKind) {
+  awaitingConnect.value = s
+  ui.openTaskConnect(s)
+}
+watch(
+  () => tasks.offeredSources.map((s) => s.source),
+  (offered) => {
+    const next = reconcileSource(offered, source.value, awaitingConnect.value)
+    if (next && next === awaitingConnect.value) awaitingConnect.value = null
+    if (next !== source.value) source.value = next
+  },
 )
 
 const boardItems = computed(() =>
@@ -100,6 +164,7 @@ watch(open, (isOpen) => {
   boardId.value = ''
   issueType.value = ''
   labels.value = ''
+  awaitingConnect.value = null
   source.value = ui.bugHunt?.source ?? tasks.offeredSources[0]?.source ?? undefined
   containerId.value = ui.bugHunt?.containerId ?? containerItems.value[0]?.value
   if (source.value) hunt.loadBoards(source.value)
@@ -193,16 +258,16 @@ const STATUS_KEYS: Record<BugHuntAnalysisStatus, string> = {
       <div v-if="!tasks.anyOffered" class="space-y-3 text-center">
         <UIcon name="i-lucide-plug" class="mx-auto h-8 w-8 text-slate-500" />
         <p class="text-sm text-slate-400">{{ t('bugHunt.connectFirst') }}</p>
-        <div class="flex justify-center gap-2">
+        <div class="flex flex-wrap justify-center gap-2">
           <UButton
-            v-for="s in tasks.sources"
-            :key="s.source"
+            v-for="choice in addableSources"
+            :key="choice.source"
             color="primary"
             variant="soft"
-            :icon="s.icon"
-            @click="ui.openTaskConnect(s.source)"
+            :icon="choice.icon"
+            @click="addSource(choice.source)"
           >
-            {{ t('bugHunt.connectSource', { label: s.label }) }}
+            {{ addLabel(choice) }}
           </UButton>
         </div>
       </div>
@@ -217,7 +282,24 @@ const STATUS_KEYS: Record<BugHuntAnalysisStatus, string> = {
 
         <div class="grid gap-3 sm:grid-cols-2">
           <UFormField :label="t('bugHunt.tracker')">
-            <USelect v-model="source" :items="sourceItems" class="w-full" />
+            <!-- The selector is also the way to ADD a tracker: each entry in the second group
+                 opens that tracker's own connect screen over this modal, so the hunt (and
+                 anything typed into it) is still here when the user comes back. -->
+            <UDropdownMenu
+              :items="sourceMenu"
+              :content="{ side: 'bottom', align: 'start' }"
+              class="w-full"
+            >
+              <UButton
+                color="neutral"
+                variant="soft"
+                :icon="descriptor?.icon"
+                trailing-icon="i-lucide-chevron-down"
+                class="w-full justify-between"
+              >
+                <span class="truncate">{{ descriptor?.label ?? t('bugHunt.pickTracker') }}</span>
+              </UButton>
+            </UDropdownMenu>
           </UFormField>
 
           <UFormField :label="t('bugHunt.board')">

package/app/components/tasks/ContextIssuePicker.vue

@@ -21,7 +21,7 @@ import type { TaskSourceReadReason } from '@cat-factory/contracts'
 import type { SourceTask, TaskSearchResult, TaskSourceKind } from '~/types/domain'
 import { apiErrorReason } from '~/composables/api/errors'
 import EmptyState from '~/components/common/EmptyState.vue'
-import { buildSourceChoices, reconcileSource } from '~/components/tasks/ContextIssuePicker.logic'
+import { buildSourceChoices, reconcileSource } from '~/utils/taskSources'
 
 const props = defineProps<{
   /** contextKeys already staged by the caller, so they're filtered out / not re-offered. */

package/app/utils/initiative.spec.ts

@@ -1,7 +1,7 @@
 import { INITIATIVE_ITEM_TERMINAL_STATUSES } from '@cat-factory/contracts'
 import { describe, it, expect } from 'vitest'
-import type { InitiativeItem, InitiativePhase } from '~/types/domain'
-import { pendingCheckpointPhase } from './initiative'
+import type { InitiativeItem, InitiativePhase, InitiativeQa } from '~/types/domain'
+import { isPendingQuestion, orderInterviewQuestions, pendingCheckpointPhase } from './initiative'
 
 // `pendingCheckpointPhase` mirrors the backend `pendingCheckpoint` (orchestration
 // `initiative.logic.ts`); these pin the same ordering/edge cases the loop pauses on, so the
@@ -71,3 +71,82 @@ describe('pendingCheckpointPhase', () => {
     expect(pendingCheckpointPhase(phases, [item('a', 'p1', status)])?.id).toBe('p1')
   })
 })
+
+// `isPendingQuestion` mirrors the backend rule of the same name (orchestration
+// `initiative.logic.ts`); `orderInterviewQuestions` is what the planning window renders by, so a
+// multi-round interview puts what the human still owes an answer above what they already settled.
+
+const qa = (over: Partial<InitiativeQa> & { id: string }): InitiativeQa => ({
+  question: over.id,
+  answer: '',
+  status: 'open',
+  ...over,
+})
+
+describe('isPendingQuestion', () => {
+  it('is pending while unanswered and not dismissed', () => {
+    expect(isPendingQuestion(qa({ id: 'a' }))).toBe(true)
+  })
+
+  it('is settled once answered', () => {
+    expect(isPendingQuestion(qa({ id: 'a', answer: 'yes' }))).toBe(false)
+  })
+
+  it('treats a whitespace-only answer as unanswered', () => {
+    expect(isPendingQuestion(qa({ id: 'a', answer: '   \n' }))).toBe(true)
+  })
+
+  it('is settled once dismissed, answered or not', () => {
+    expect(isPendingQuestion(qa({ id: 'a', status: 'dismissed' }))).toBe(false)
+  })
+
+  it('treats an absent answer/status (a hand-authored exchange) as pending', () => {
+    expect(isPendingQuestion({})).toBe(true)
+  })
+})
+
+describe('orderInterviewQuestions', () => {
+  const ids = (list: InitiativeQa[]) => orderInterviewQuestions(list).map((q) => q.id)
+
+  it('floats a later round of unanswered questions above the settled digest', () => {
+    // The shape the backend's `[...retainedQa, ...pending]` append produces on round two.
+    const list = [
+      qa({ id: 'r1-answered', answer: 'yes' }),
+      qa({ id: 'r1-dismissed', status: 'dismissed' }),
+      qa({ id: 'r2-a' }),
+      qa({ id: 'r2-b' }),
+    ]
+    expect(ids(list)).toEqual(['r2-a', 'r2-b', 'r1-answered', 'r1-dismissed'])
+  })
+
+  it('keeps chronological order within each group', () => {
+    const list = [
+      qa({ id: 'p1' }),
+      qa({ id: 's1', answer: 'yes' }),
+      qa({ id: 'p2' }),
+      qa({ id: 's2', status: 'dismissed' }),
+      qa({ id: 'p3' }),
+    ]
+    expect(ids(list)).toEqual(['p1', 'p2', 'p3', 's1', 's2'])
+  })
+
+  it('leaves a first round (all pending) exactly as the interviewer asked it', () => {
+    const list = [qa({ id: 'a' }), qa({ id: 'b' }), qa({ id: 'c' })]
+    expect(ids(list)).toEqual(['a', 'b', 'c'])
+  })
+
+  it('leaves a fully settled interview in its digest order', () => {
+    const list = [qa({ id: 'a', answer: 'x' }), qa({ id: 'b', status: 'dismissed' })]
+    expect(ids(list)).toEqual(['a', 'b'])
+  })
+
+  it('does not mutate the stored order (the interviewer prompt + tracker digest read it)', () => {
+    const list = [qa({ id: 'answered', answer: 'x' }), qa({ id: 'pending' })]
+    orderInterviewQuestions(list)
+    expect(list.map((q) => q.id)).toEqual(['answered', 'pending'])
+  })
+
+  it('handles an empty interview', () => {
+    expect(orderInterviewQuestions([])).toEqual([])
+  })
+})

package/app/utils/initiative.ts

@@ -6,6 +6,7 @@ import type {
   InitiativePhase,
   InitiativePresetDescriptor,
   InitiativePresetInputs,
+  InitiativeQa,
   InitiativeStatus,
 } from '~/types/domain'
 
@@ -111,6 +112,37 @@ export function initiativeProgress(
   }
 }
 
+/**
+ * Whether a planning-interview question still needs a human answer: not dismissed, and no answer
+ * yet. Mirrors the backend `isPendingQuestion` (orchestration `initiative.logic.ts`) — the rule the
+ * interviewer, the retained-across-rounds digest and the continue gate all key off — so the window's
+ * pending list, its unanswered counter and its render order can never disagree with the engine
+ * about what is still open.
+ */
+export function isPendingQuestion(q: Partial<Pick<InitiativeQa, 'answer' | 'status'>>): boolean {
+  return q.status !== 'dismissed' && (q.answer ?? '').trim().length === 0
+}
+
+/**
+ * Interview questions in the order the planning window renders them: everything still pending
+ * first, everything already settled (answered, or dismissed as not relevant) after, each group
+ * keeping the interviewer's own chronological order.
+ *
+ * Each round APPENDS its new questions after the digest retained from the previous ones (backend
+ * `applyInterviewQuestions`: `[...retainedQa, ...pending]`), so from round two onwards the only
+ * questions the human still has to act on sit below a growing wall of ones they already settled —
+ * on a long interview, below the fold entirely. This reorders the RENDER only; the stored `qa`
+ * order, which the interviewer prompt and the in-repo tracker digest read, is untouched.
+ */
+export function orderInterviewQuestions<T extends Partial<Pick<InitiativeQa, 'answer' | 'status'>>>(
+  qa: readonly T[],
+): T[] {
+  const pending: T[] = []
+  const settled: T[] = []
+  for (const q of qa) (isPendingQuestion(q) ? pending : settled).push(q)
+  return [...pending, ...settled]
+}
+
 /**
  * The phase whose completed checkpoint (D2) is awaiting a human, or null. Mirrors the backend
  * `pendingCheckpoint` (orchestration `initiative.logic.ts`) so the SPA recomputes the pending

package/app/{components/tasks/ContextIssuePicker.logic.spec.ts → utils/taskSources.spec.ts}

@@ -1,12 +1,12 @@
 import { describe, it, expect } from 'vitest'
-import { buildSourceChoices, reconcileSource } from './ContextIssuePicker.logic'
+import { buildSourceChoices, reconcileSource } from './taskSources'
 import type { TaskSourceState } from '~/types/domain'
 
 /**
- * The pure source-selection behind `<ContextIssuePicker>`. Pins what the always-visible
- * selector promises: the tracker in use is named even when it is the only one, a tracker
- * the workspace hasn't got yet is offered as something to ADD (worded for its actual
- * state), and the selection stays valid as the offered set changes underneath it.
+ * The pure tracker-selection behind `<ContextIssuePicker>` and `<BugHuntModal>`. Pins what
+ * the always-visible selector promises: the tracker in use is named even when it is the only
+ * one, a tracker the workspace hasn't got yet is offered as something to ADD (worded for its
+ * actual state), and the selection stays valid as the offered set changes underneath it.
  */
 const state = (source: string, { available = true, enabled = true } = {}): TaskSourceState =>
   ({
@@ -55,6 +55,17 @@ describe('buildSourceChoices', () => {
     ])
   })
 
+  // What a surface's "nothing connected yet" state renders its add buttons from: it flattens
+  // the groups, so every choice there has to be addable. A `select` leaking through would
+  // offer to connect a tracker the workspace already has.
+  it('yields only addable choices when the workspace offers no tracker', () => {
+    const choices = buildSourceChoices(
+      [state('jira', { available: false }), state('linear', { enabled: false })],
+      undefined,
+    ).flat()
+    expect(choices.map((c) => c.action)).toEqual(['connect', 'enable'])
+  })
+
   it('drops empty groups so the menu renders no stray separator', () => {
     expect(buildSourceChoices([state('github')], 'github')).toHaveLength(1)
     expect(buildSourceChoices([state('jira', { available: false })], undefined)).toHaveLength(1)

package/app/{components/tasks/ContextIssuePicker.logic.ts → utils/taskSources.ts}

@@ -1,18 +1,20 @@
 import type { TaskSourceKind, TaskSourceState } from '~/types/domain'
 
 /**
- * Pure source-selection logic for `<ContextIssuePicker>`: which tracker the picker is
- * searching, and what the source menu offers. Kept out of the component so both the
- * template's `computed`s and the unit spec call the same code.
+ * Pure tracker-selection logic shared by every surface that picks a task source: which
+ * tracker is selected, and what its menu offers. Kept out of the components so their
+ * `computed`s and the unit spec call the same code.
  *
  * The menu is deliberately two-tier — pick an already-offered tracker, or go and add
- * one — because "attach a context issue" is where a user first discovers a tracker is
- * missing, and sending them to the Integrations hub loses their in-progress task.
+ * one — because a tracker-picking surface is exactly where a user discovers the tracker
+ * they want is missing, and sending them off to the Integrations hub loses whatever they
+ * had in progress. Today `<ContextIssuePicker>` (attach a context issue) and
+ * `<BugHuntModal>` (scan a board for bugs) both render it.
  */
 
-/** One row of the picker's source menu. */
+/** One row of a tracker menu. */
 export type SourceChoice =
-  /** An offered tracker the picker can search right now. */
+  /** An offered tracker the surface can use right now. */
   | { action: 'select'; source: TaskSourceKind; label: string; icon: string; active: boolean }
   /**
    * A configured tracker that is not offered yet, so it can be added from here. `connect`
@@ -23,8 +25,8 @@ export type SourceChoice =
   | { action: 'connect' | 'enable'; source: TaskSourceKind; label: string; icon: string }
 
 /**
- * The picker's source menu, as non-empty groups (the offered trackers, then the ones the
- * user could add). Empty groups are dropped so the menu never renders a stray separator.
+ * A tracker menu, as non-empty groups (the offered trackers, then the ones the user could
+ * add). Empty groups are dropped so the menu never renders a stray separator.
  */
 export function buildSourceChoices(
   sources: TaskSourceState[],
@@ -54,13 +56,13 @@ export function buildSourceChoices(
 }
 
 /**
- * The source the picker should hold once the offered set changes — after a connect, a
+ * The source a surface should hold once the offered set changes — after a connect, a
  * disconnect, or the per-workspace toggle flipping elsewhere.
  *
  * `awaiting` is the tracker the user just left to connect: the moment it becomes offered
  * it wins, so they land back on the source they went to add rather than on whatever was
  * selected before. Otherwise a still-offered selection is kept, and a selection that
- * stopped being offered falls back to the first one (searching a tracker the workspace no
+ * stopped being offered falls back to the first one (reading a tracker the workspace no
  * longer offers only yields errors).
  */
 export function reconcileSource(

package/i18n/locales/de.json

@@ -3444,6 +3444,8 @@
     "intro": "Durchsuche ein Tracker-Board nach offenen, nicht zugewiesenen Fehlern und bewerte sie nach Auswirkung im Verhältnis zum geschätzten Aufwand. Wähle einen aus, und er wird zu einer Aufgabe, die die Fehlerbehebungs-Pipeline durchläuft.",
     "connectFirst": "Verbinde oder aktiviere zuerst eine Aufgabenquelle.",
     "connectSource": "{label} verbinden",
+    "enableSource": "{label} aktivieren",
+    "pickTracker": "Tracker auswählen",
     "needFrameFirst": "Füge zuerst einen Service-Rahmen zum Board hinzu, damit ein übernommener Fehler irgendwo landen kann.",
     "tracker": "Tracker",
     "board": "Board",

package/i18n/locales/en.json

@@ -3867,6 +3867,8 @@
     "intro": "Scan a tracker board for open, unassigned bugs and rank them by impact against how hard each looks to fix. Pick one and it becomes a task running the bug-fix pipeline.",
     "connectFirst": "Connect or enable a task source first.",
     "connectSource": "Connect {label}",
+    "enableSource": "Enable {label}",
+    "pickTracker": "Pick a tracker",
     "needFrameFirst": "Add a service frame to the board first, so a picked-up bug has somewhere to land.",
     "tracker": "Tracker",
     "board": "Board",

package/i18n/locales/es.json

@@ -3756,6 +3756,8 @@
     "intro": "Explora un tablero del gestor de incidencias en busca de errores abiertos y sin asignar, y clasifícalos por impacto frente a lo difícil que parece arreglar cada uno. Elige uno y se convertirá en una tarea que ejecuta la canalización de corrección de errores.",
     "connectFirst": "Conecta o activa primero una fuente de tareas.",
     "connectSource": "Conectar {label}",
+    "enableSource": "Habilitar {label}",
+    "pickTracker": "Elige un gestor de incidencias",
     "needFrameFirst": "Añade primero un marco de servicio al tablero para que el error elegido tenga dónde aterrizar.",
     "tracker": "Gestor de incidencias",
     "board": "Tablero",

package/i18n/locales/fr.json

@@ -3756,6 +3756,8 @@
     "intro": "Parcourez un tableau du gestionnaire de tickets à la recherche de bugs ouverts et non assignés, puis classez-les selon leur impact face à la difficulté apparente du correctif. Choisissez-en un et il devient une tâche qui exécute le pipeline de correction.",
     "connectFirst": "Connectez ou activez d'abord une source de tâches.",
     "connectSource": "Connecter {label}",
+    "enableSource": "Activer {label}",
+    "pickTracker": "Choisir un gestionnaire de tickets",
     "needFrameFirst": "Ajoutez d'abord un cadre de service au tableau, pour que le bug retenu ait un endroit où atterrir.",
     "tracker": "Gestionnaire de tickets",
     "board": "Tableau",

package/i18n/locales/he.json

@@ -3767,6 +3767,8 @@
     "intro": "סרוק לוח של מערכת מעקב לאיתור באגים פתוחים שאינם משויכים לאיש, ודרג אותם לפי ההשפעה מול מידת הקושי המשוערת בתיקון. בחר אחד והוא יהפוך למשימה שמריצה את צינור תיקון הבאגים.",
     "connectFirst": "חבר או הפעל תחילה מקור משימות.",
     "connectSource": "חבר את {label}",
+    "enableSource": "הפעל {label}",
+    "pickTracker": "בחר מערכת מעקב",
     "needFrameFirst": "הוסף תחילה מסגרת שירות ללוח, כדי שלבאג הנבחר יהיה לאן להגיע.",
     "tracker": "מערכת מעקב",
     "board": "לוח",

package/i18n/locales/it.json

@@ -3444,6 +3444,8 @@
     "intro": "Esplora una bacheca del tracker alla ricerca di bug aperti e non assegnati e classificali per impatto rispetto a quanto sembra difficile risolverli. Scegline uno e diventerà un'attività che esegue la pipeline di correzione.",
     "connectFirst": "Collega o abilita prima una sorgente di attività.",
     "connectSource": "Collega {label}",
+    "enableSource": "Abilita {label}",
+    "pickTracker": "Scegli un tracker",
     "needFrameFirst": "Aggiungi prima un frame di servizio alla bacheca, così il bug scelto ha dove atterrare.",
     "tracker": "Tracker",
     "board": "Bacheca",

package/i18n/locales/ja.json

@@ -3768,6 +3768,8 @@
     "intro": "トラッカーのボードから未割り当ての未解決バグを探し、影響度と修正の難しさの比で並べ替えます。ひとつ選ぶと、バグ修正パイプラインを実行するタスクになります。",
     "connectFirst": "先にタスクソースを接続または有効化してください。",
     "connectSource": "{label} を接続",
+    "enableSource": "{label} を有効化",
+    "pickTracker": "トラッカーを選択",
     "needFrameFirst": "選んだバグの受け入れ先が必要なので、先にサービスフレームをボードに追加してください。",
     "tracker": "トラッカー",
     "board": "ボード",

package/i18n/locales/pl.json

@@ -3756,6 +3756,8 @@
     "intro": "Przeszukaj tablicę systemu zgłoszeń w poszukiwaniu otwartych, nieprzypisanych błędów i uszereguj je według wpływu w stosunku do przewidywanej trudności naprawy. Wybierz jeden, a stanie się zadaniem uruchamiającym potok naprawy błędów.",
     "connectFirst": "Najpierw połącz lub włącz źródło zadań.",
     "connectSource": "Połącz {label}",
+    "enableSource": "Włącz {label}",
+    "pickTracker": "Wybierz system zgłoszeń",
     "needFrameFirst": "Najpierw dodaj ramkę usługi do tablicy, aby wybrany błąd miał gdzie wylądować.",
     "tracker": "System zgłoszeń",
     "board": "Tablica",

package/i18n/locales/tr.json

@@ -3768,6 +3768,8 @@
     "intro": "Bir takip panosunu açık ve kimseye atanmamış hatalar için tarayın ve bunları etkilerine karşı düzeltmenin ne kadar zor göründüğüne göre sıralayın. Birini seçin, hata düzeltme hattını çalıştıran bir göreve dönüşsün.",
     "connectFirst": "Önce bir görev kaynağı bağlayın veya etkinleştirin.",
     "connectSource": "{label} bağla",
+    "enableSource": "{label} etkinleştir",
+    "pickTracker": "Bir takip aracı seçin",
     "needFrameFirst": "Seçilen hatanın ineceği bir yer olması için önce panoya bir servis çerçevesi ekleyin.",
     "tracker": "Takip aracı",
     "board": "Pano",

package/i18n/locales/uk.json

@@ -3756,6 +3756,8 @@
     "intro": "Перегляньте дошку трекера у пошуках відкритих і не призначених нікому помилок та впорядкуйте їх за впливом щодо того, наскільки складним видається виправлення. Оберіть одну, і вона стане завданням, що виконує конвеєр виправлення помилок.",
     "connectFirst": "Спершу під’єднайте або увімкніть джерело завдань.",
     "connectSource": "Під'єднати {label}",
+    "enableSource": "Увімкнути {label}",
+    "pickTracker": "Оберіть трекер",
     "needFrameFirst": "Спершу додайте рамку сервісу на дошку, щоб обрана помилка мала куди потрапити.",
     "tracker": "Трекер",
     "board": "Дошка",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cat-factory/app",
-  "version": "0.179.0",
+  "version": "0.180.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",