@cat-factory/app 0.300.0 → 0.300.2

package/app/composables/useArtifactBlobs.ts

@@ -1,4 +1,5 @@
 import { reactive } from 'vue'
+import type { LoadState } from '~/types/load-state'
 import { useWorkspaceStore } from '~/stores/workspace'
 
 /**
@@ -15,7 +16,7 @@ import { useWorkspaceStore } from '~/stores/workspace'
  * Both the visual-confirmation gate and the test-report window use this, so neither has to
  * own blob plumbing or depend on the other's Pinia store.
  */
-export type ArtifactBlobStatus = 'idle' | 'loading' | 'ready' | 'error'
+export type ArtifactBlobStatus = LoadState
 
 export function useArtifactBlobs() {
   const ws = useWorkspaceStore()

package/app/composables/useModalOpen.spec.ts

@@ -0,0 +1,51 @@
+import { describe, expect, it, vi } from 'vitest'
+import { effectScope, nextTick, ref } from 'vue'
+import { onModalOpen } from './useModalOpen'
+
+/**
+ * Register `onModalOpen` with `open` already at `mountedOpen`, which is what a modal's setup does.
+ * That first value is the whole point: the page mounts most panels only WHILE their flag is set,
+ * so a modal's `open` is already `true` by the time its own setup runs.
+ */
+function register(mountedOpen: boolean) {
+  const open = ref(mountedOpen)
+  const ran = vi.fn()
+  const scope = effectScope()
+  scope.run(() => onModalOpen(open, ran))
+  return { open, ran, stop: () => scope.stop() }
+}
+
+describe('onModalOpen', () => {
+  it('runs on the render the panel MOUNTS on, when it mounts already open', () => {
+    // The bug this exists to make unrepresentable: a change-only `watch(open)` never fires for a
+    // `v-if`-mounted modal, so whatever the body seeds (a picker's default, the read that fills a
+    // catalog) never happens and the panel opens with an unselected control and a dead confirm.
+    const { ran, stop } = register(true)
+
+    expect(ran).toHaveBeenCalledTimes(1)
+    stop()
+  })
+
+  it('does not run for a panel that is mounted CLOSED', () => {
+    // The always-mounted half of the SPA. The same call has to be correct there, or this could not
+    // be the one thing every site uses and each author would be back to deciding per site.
+    const { ran, stop } = register(false)
+
+    expect(ran).not.toHaveBeenCalled()
+    stop()
+  })
+
+  it('runs again on each later open, and never on a close', async () => {
+    const { open, ran, stop } = register(false)
+
+    open.value = true
+    await nextTick()
+    open.value = false
+    await nextTick()
+    open.value = true
+    await nextTick()
+
+    expect(ran).toHaveBeenCalledTimes(2)
+    stop()
+  })
+})

package/app/composables/useModalOpen.ts

@@ -0,0 +1,31 @@
+import { watch } from 'vue'
+import type { WatchSource } from 'vue'
+
+/**
+ * Run `fn` whenever a modal opens, INCLUDING the render it mounts on.
+ *
+ * This exists because `watch(open, (isOpen) => { if (isOpen) … })` is wrong in this SPA and reads
+ * as right. The page mounts most panels only WHILE their open flag is set
+ * (`<AssistantModal v-if="ui.assistantOpen" />`), so `open` is already `true` when the component
+ * sets up and a change-only watcher never fires at all: whatever the body seeds (a picker's
+ * default, the read that fills a catalog) never happens, and the panel opens with an unselected
+ * control and a confirm button that cannot be pressed. Nothing throws, which is why it survived in
+ * several modals at once.
+ *
+ * `{ immediate: true }` is the whole fix, and a shared helper is how it stops being per-site
+ * knowledge: a panel that IS always mounted passes a `false` on that first run and the body is
+ * skipped, so this is correct either way and nobody has to know which kind they are writing.
+ *
+ * Only for work done on the way IN. A watcher acting on the CLOSE edge (emitting `close`, revoking
+ * object URLs) stays a plain `watch`: it has nothing to do at mount, and running it there would
+ * announce a close that never happened.
+ */
+export function onModalOpen(open: WatchSource<boolean>, fn: () => void): void {
+  watch(
+    open,
+    (isOpen) => {
+      if (isOpen) fn()
+    },
+    { immediate: true },
+  )
+}

package/app/stores/assistant.spec.ts

@@ -0,0 +1,183 @@
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest'
+import { useAssistantStore } from '~/stores/assistant'
+import { useWorkspaceStore } from '~/stores/workspace'
+import { ApiError } from '~/composables/api/errors'
+import type { AssistantCapability } from '~/types/domain'
+
+// What the modal reads to decide whether it may offer the prompt box, and whether that box may be
+// submitted. The capability's own ANSWER is two independent bits (is a model wired, and is there
+// anything for it to do); on their own they cannot say whether anyone has asked yet, which is a
+// third fact the modal has to render differently from both.
+
+/**
+ * Stub `useApi` ONCE, behind a handler the test can swap. The store resolves `useApi()` at setup,
+ * so re-stubbing after `useAssistantStore()` would leave it holding the first stub for ever.
+ *
+ * The handler is given the abort signal the store attaches its deadline to, so a test can assert
+ * on what a timed-out read does to the request as well as to the state.
+ */
+function stubApi(): {
+  store: ReturnType<typeof useAssistantStore>
+  serve: (fn: (signal: AbortSignal) => Promise<AssistantCapability>) => void
+} {
+  let handler: (signal: AbortSignal) => Promise<AssistantCapability> = () =>
+    Promise.resolve({ available: true, actions: ['declare-service-dependency'] })
+  vi.stubGlobal('useApi', () => ({
+    getAssistantCapability: (_ws: string, signal: AbortSignal) => handler(signal),
+  }))
+  return {
+    store: useAssistantStore(),
+    serve: (fn) => {
+      handler = fn
+    },
+  }
+}
+
+const failing = (status = 503) =>
+  Promise.reject(new ApiError(status, { error: { code: 'unavailable', message: 'nope' } }))
+
+describe('assistant store: the capability read', () => {
+  beforeEach(() => {
+    useWorkspaceStore().workspaceId = 'ws1'
+  })
+
+  it('starts idle, which is not the same fact as unavailable', () => {
+    const { store } = stubApi()
+
+    expect(store.capabilityRead).toBe('idle')
+    expect(store.capability).toBeNull()
+    expect(store.available).toBe(false)
+  })
+
+  it('holds `loading` while the read is in flight', async () => {
+    const { store, serve } = stubApi()
+    let answer!: (capability: AssistantCapability) => void
+    serve(() => new Promise((resolve) => (answer = resolve)))
+
+    const inFlight = store.loadCapability()
+    expect(store.capabilityRead).toBe('loading')
+
+    answer({ available: true, actions: ['declare-service-dependency'] })
+    await inFlight
+
+    expect(store.capabilityRead).toBe('ready')
+    expect(store.actions).toEqual(['declare-service-dependency'])
+  })
+
+  it('KEEPS the answer it holds while a re-read is in flight', async () => {
+    // Re-opening the modal re-reads. Clearing the answer for the duration would replace the box
+    // with a waiting state on every open, for a fact the store can already state.
+    const { store, serve } = stubApi()
+    await store.loadCapability()
+
+    serve(() => new Promise(() => {}))
+    void store.loadCapability()
+
+    expect(store.capabilityRead).toBe('loading')
+    expect(store.available).toBe(true)
+    expect(store.actions).toEqual(['declare-service-dependency'])
+  })
+
+  it('records a read that answered "no model" as read, so it can be told from an outage', async () => {
+    const { store, serve } = stubApi()
+    serve(() => Promise.resolve({ available: false, actions: [] }))
+
+    await store.loadCapability()
+
+    expect(store.capabilityRead).toBe('ready')
+    expect(store.available).toBe(false)
+  })
+
+  it('marks a FAILED read as failed and does not throw', async () => {
+    // The failure is REPORTED by the panel this state puts on screen, which is where the retry
+    // lives too. Throwing it as well would have the modal toast a second, non-dismissing copy of
+    // the same sentence over that panel, once per retry.
+    const { store, serve } = stubApi()
+    serve(() => failing())
+
+    await expect(store.loadCapability()).resolves.toBeUndefined()
+
+    expect(store.capabilityRead).toBe('error')
+    expect(store.capability).toBeNull()
+    expect(store.available).toBe(false)
+  })
+
+  it('drops a previous answer when a later read fails', async () => {
+    // A retry that fails must not leave the box open on the strength of the read before it: the
+    // deployment's model may have gone away with whatever took the endpoint down.
+    const { store, serve } = stubApi()
+    serve(() => Promise.resolve({ available: true, actions: ['add-service-from-repo'] }))
+    await store.loadCapability()
+
+    serve(() => failing(500))
+    await store.loadCapability()
+
+    expect(store.capability).toBeNull()
+    expect(store.actions).toEqual([])
+  })
+
+  it('recovers on a retry that answers', async () => {
+    const { store, serve } = stubApi()
+    serve(() => failing(502))
+    await store.loadCapability()
+
+    serve(() => Promise.resolve({ available: true, actions: ['create-task-from-issue'] }))
+    await store.loadCapability()
+
+    expect(store.capabilityRead).toBe('ready')
+    expect(store.available).toBe(true)
+  })
+
+  it('settles overlapping reads in the order they STARTED, not the order they answer', async () => {
+    // A slow success that lands after the fast failure which superseded it would otherwise
+    // re-offer the box on an answer older than the failure that replaced it.
+    const { store, serve } = stubApi()
+    let answerSlow!: (capability: AssistantCapability) => void
+    serve(() => new Promise((resolve) => (answerSlow = resolve)))
+    const slow = store.loadCapability()
+
+    serve(() => failing())
+    await store.loadCapability()
+    expect(store.capabilityRead).toBe('error')
+
+    answerSlow({ available: true, actions: ['declare-service-dependency'] })
+    await slow
+
+    expect(store.capabilityRead).toBe('error')
+    expect(store.capability).toBeNull()
+  })
+})
+
+describe('assistant store: the capability read deadline', () => {
+  beforeEach(() => {
+    useWorkspaceStore().workspaceId = 'ws1'
+    vi.useFakeTimers()
+  })
+  afterEach(() => {
+    vi.useRealTimers()
+  })
+
+  it('fails a read that never settles, and ABORTS the request it gave up on', async () => {
+    // The shared client sets no timeout, so a connection accepted and never answered would leave
+    // the modal waiting for ever: no answer, no failure, and so no retry either, since the retry
+    // is what a failed read puts on screen.
+    const { store, serve } = stubApi()
+    let aborted = false
+    serve(
+      (signal) =>
+        new Promise((_resolve, reject) => {
+          signal.addEventListener('abort', () => {
+            aborted = true
+            reject(new Error('aborted'))
+          })
+        }),
+    )
+
+    const read = store.loadCapability()
+    await vi.advanceTimersByTimeAsync(10_000)
+    await read
+
+    expect(aborted).toBe(true)
+    expect(store.capabilityRead).toBe('error')
+  })
+})

package/app/stores/assistant.ts

@@ -1,8 +1,20 @@
 import { defineStore } from 'pinia'
 import { computed, ref } from 'vue'
 import type { AssistantAnswer, AssistantCapability, AssistantTurn } from '~/types/domain'
+import type { LoadState } from '~/types/load-state'
 import { useWorkspaceStore } from '~/stores/workspace'
 
+/**
+ * How long the capability read waits before it counts as failed.
+ *
+ * The shared client sets no timeout, so a connection that is accepted and never answered (a proxy
+ * holding it open, a wedged worker) leaves the GET pending for ever. Without a deadline that is a
+ * modal whose read never settles: no answer, no failure, and therefore no retry either, since the
+ * retry lives in what a FAILED read puts on screen. The read itself is a tiny in-memory answer on
+ * the backend, so anything past a few seconds is already a connection that is not coming back.
+ */
+const CAPABILITY_DEADLINE_MS = 10_000
+
 /**
  * In-app assistant state: what this deployment's assistant can do, and the last turn's outcome.
  *
@@ -11,25 +23,78 @@ import { useWorkspaceStore } from '~/stores/workspace'
  * live stream like any other, so the frame or task shows up without this store touching the board).
  * Keeping a transcript would be a second, staler record of changes the board already carries.
  *
- * Failures are NOT held here: every refusal a turn can raise is a `DomainError` the shared error
- * funnel (`usePipelineErrorToast`) already renders translated, copyable and with its request id.
- * The three OUTCOMES are the ones this store keeps, because they are answers rather than errors.
+ * Failures of a TURN are not held here: every refusal a turn can raise is a `DomainError` the
+ * shared error funnel (`usePipelineErrorToast`) already renders translated, copyable and with its
+ * request id. The three OUTCOMES are the ones this store keeps, because they are answers rather
+ * than errors. A failed capability READ is the exception, and it is state rather than a throw: see
+ * `loadCapability`.
  */
 export const useAssistantStore = defineStore('assistant', () => {
   const api = useApi()
   const workspace = useWorkspaceStore()
 
   const capability = ref<AssistantCapability | null>(null)
+  const capabilityRead = ref<LoadState>('idle')
   const turn = ref<AssistantTurn | null>(null)
   const running = ref(false)
 
-  /** Whether a model is wired at all; unknown (not yet read) reads as unavailable. */
+  /**
+   * How many reads have STARTED. Compared before every write, so two overlapping reads settle in
+   * the order they were ISSUED rather than the order they answer: a slow success that lands after
+   * the fast failure that superseded it would otherwise re-offer the box on the older answer.
+   */
+  let reads = 0
+
+  /** Whether a model is wired at all. Only meaningful once `capabilityRead` says `ready`. */
   const available = computed(() => capability.value?.available === true)
   const actions = computed(() => capability.value?.actions ?? [])
 
-  /** Read what the assistant can do here. Idempotent: re-reading replaces the answer. */
+  /**
+   * Read what the assistant can do here. Idempotent: re-reading replaces the answer.
+   *
+   * A re-read KEEPS the answer it already has while it is in flight, so the surface stays on the
+   * fact it can already state instead of dropping back to a spinner every time the modal is
+   * re-opened. Only a failure clears it, because a deployment's model may have gone away with
+   * whatever took the endpoint down.
+   *
+   * The failure is recorded, not thrown. It is reported in place: `error` is what puts the
+   * explanation and the retry button on screen, and toasting it as well would stack a second,
+   * non-dismissing copy of the same sentence over the panel that already says it, once per retry.
+   */
   async function loadCapability(): Promise<void> {
-    capability.value = await api.getAssistantCapability(workspace.requireId())
+    const read = ++reads
+    capabilityRead.value = 'loading'
+    try {
+      const answer = await withDeadline((signal) =>
+        api.getAssistantCapability(workspace.requireId(), signal),
+      )
+      if (read !== reads) return
+      capability.value = answer
+      capabilityRead.value = 'ready'
+    } catch {
+      if (read !== reads) return
+      capability.value = null
+      capabilityRead.value = 'error'
+    }
+  }
+
+  /** Read under {@link CAPABILITY_DEADLINE_MS}, ABORTING the request when it expires. */
+  async function withDeadline(
+    send: (signal: AbortSignal) => Promise<AssistantCapability>,
+  ): Promise<AssistantCapability> {
+    const controller = new AbortController()
+    let timer: ReturnType<typeof setTimeout> | undefined
+    try {
+      return await new Promise<AssistantCapability>((resolve, reject) => {
+        timer = setTimeout(() => {
+          controller.abort()
+          reject(new Error(`Assistant capability read timed out after ${CAPABILITY_DEADLINE_MS}ms`))
+        }, CAPABILITY_DEADLINE_MS)
+        send(controller.signal).then(resolve, reject)
+      })
+    } finally {
+      clearTimeout(timer)
+    }
   }
 
   /**
@@ -65,5 +130,16 @@ export const useAssistantStore = defineStore('assistant', () => {
     turn.value = null
   }
 
-  return { capability, turn, running, available, actions, loadCapability, run, answer, reset }
+  return {
+    capability,
+    capabilityRead,
+    turn,
+    running,
+    available,
+    actions,
+    loadCapability,
+    run,
+    answer,
+    reset,
+  }
 })

package/app/types/domain.ts

@@ -125,6 +125,10 @@ import type { AgentCategory, AgentKind, AgentTier, PipelinePurpose } from '@cat-
 // single source of truth lives in the contracts package.
 export { DOC_KINDS, DOC_KIND_FIELDS } from '@cat-factory/contracts'
 
+// The assistant's prompt cap is a runtime value too: the box states the limit and refuses a
+// submission over it, and the wire schema holds the same number.
+export { ASSISTANT_PROMPT_MAX } from '@cat-factory/contracts'
+
 /** A draggable agent definition shown in the agent palette. Frontend-only. */
 export interface AgentArchetype {
   kind: AgentKind

package/app/types/load-state.ts

@@ -0,0 +1,18 @@
+/**
+ * How far a read has got: the SPA's one vocabulary for load progress.
+ *
+ * Four states rather than a nullable value, because an absent value is not a single fact. "Nobody
+ * asked", "the read is in flight" and "the read failed" need three different answers on screen and
+ * only the middle one is temporary; collapsed into one `null` they all render as whatever the
+ * surface shows for "no data", which is usually the empty state and is wrong for two of them.
+ *
+ * A REFRESH is deliberately not a fifth member. A read that already has an answer keeps it, so a
+ * surface asking "what do I show" reads the value it holds and a surface asking "is something in
+ * flight" reads `loading`; a re-read that downgraded the surface to `loading` would replace a
+ * usable panel with a spinner for a fact it can already state.
+ *
+ * A status carrying a member this does not have keeps its own type (`NotificationSettingsStatus`
+ * distinguishes "the deployment does not offer this" from a failure, which is a fifth fact rather
+ * than a renaming of one of these four).
+ */
+export type LoadState = 'idle' | 'loading' | 'ready' | 'error'

package/app/utils/catalog.ts

@@ -862,6 +862,24 @@ export const SYSTEM_AGENT_META: Record<string, AgentArchetype> = {
     description:
       'Grades each completed agent step (smooth vs chaotic) after a run and recommends prompt/model improvements.',
   },
+  // The in-app assistant routes ONE typed sentence to one action from a closed catalog. Not a
+  // pipeline step (it declares no `category`, so it is never in the palette), but it runs an LLM
+  // on every request, so it needs display metadata here and a per-workspace model in Model
+  // Configuration. Without an entry it inherits the preset's base model like any unnamed kind,
+  // which is the right default; what it lacked was the row an operator pins a different one on,
+  // and a label anywhere a spend rollup names the kind that spent it.
+  assistant: {
+    kind: 'assistant',
+    // Intermediate, not advanced like `kaizen`: the assistant is a surface a person OPENS and
+    // spends on deliberately, several times a day, where Kaizen grades in the background on its
+    // own schedule. A kind whose cost someone can feel should not sit two levels down.
+    tier: 'intermediate',
+    label: 'Assistant',
+    icon: 'i-lucide-sparkles',
+    color: '#38bdf8',
+    description:
+      'Routes a typed request to one action the platform performs on the board (declare a dependency, add a service from a repository, file a task from a tracker issue).',
+  },
   // A polling gate (no model of its own) that watches the released PR's observability
   // signals after merge and escalates to the on-call agent on a regression. NOT in any
   // default pipeline and NOT a standing palette archetype — the palette surfaces it
@@ -913,6 +931,9 @@ export const MODEL_CONFIGURABLE_SYSTEM_KINDS: AgentArchetype[] = [
     // The PR-review Challenge Investigator — pinnable to its own (stronger) model, separately
     // from the reviewer that produced the findings.
     'challenge-investigator',
+    // The in-app assistant: one inline model call per typed request, on the workspace's preset
+    // like every other kind, and pinnable away from it here.
+    'assistant',
   ].map((kind) => SYSTEM_AGENT_META[kind]!),
   // Companions run LLMs but aren't palette-addable (they're producer toggles), so include
   // them here to keep their per-workspace default model pinnable in the Model Defaults panel.

package/i18n/locales/de.json

@@ -1179,7 +1179,7 @@
       "bugFishing": {
         "heading": "Pipeline für Fehlerbehebungen aus der Fehlersuche",
         "body": "Die Pipeline, auf der eine Behebungsaufgabe läuft, wenn Sie einen Befund aus einer Fehlersuche markieren. Jeder markierte Befund wird zu einer eigenen Aufgabe auf dieser Pipeline; wer markiert, kann die Auswahl für einen Durchgang überschreiben.",
-        "builtInDefault": "Die integrierte Fehlerbehebungs-Vorlage verwenden"
+        "builtInDefault": "Standard der Plattform verwenden (die testverifizierte Bugfix-Vorlage)"
       }
     },
     "localModelEndpoints": {
@@ -4520,9 +4520,13 @@
     "title": "Assistent",
     "intro": "Beschreiben Sie, was erledigt werden soll, und der Assistent führt es auf dem Board aus: eine Abhängigkeit zwischen zwei Services erklären, einen Service über eine Repository-URL hinzufügen oder eine Aufgabe aus einem Tracker-Ticket anlegen.",
     "unavailable": "Für diese Installation ist kein Modell konfiguriert, daher kann der Assistent keine Anfrage lesen. Richten Sie einen Modellanbieter ein, um ihn zu aktivieren.",
+    "reading": "Es wird geprüft, was der Assistent hier tun kann…",
+    "unreadable": "Es konnte nicht geprüft werden, was der Assistent hier tun kann, daher ist das Anfragefeld vorerst ausgeblendet. Versuche es in einem Moment erneut.",
+    "noActions": "Für den Assistenten dieser Installation sind keine Aktionen konfiguriert, daher kann er nichts ausführen. Konfigurieren Sie seine Aktionen, um ihn zu aktivieren.",
     "placeholder": "z. B. der Checkout-Service hängt vom Payments-Service ab",
     "submit": "Ausführen",
     "submitHint": "Strg+Enter, auf dem Mac Cmd+Enter",
+    "tooLong": "Diese Anfrage hat {length} Zeichen, der Assistent liest höchstens {limit}. Kürze sie und starte erneut.",
     "examplesTitle": "Das können Sie fragen",
     "showOnBoard": "Auf dem Board zeigen",
     "declined": "Keine Aktion des Assistenten passt zu dieser Anfrage. Er kann eine Abhängigkeit zwischen zwei Services erklären, einen Service über eine Repository-URL hinzufügen oder eine Aufgabe aus einem Tracker-Ticket anlegen.",
@@ -7071,7 +7075,8 @@
       },
       "gap": {
         "no_tester_step": "Diese Pipeline hat keinen Test-Schritt, es wurde also nichts ausgeführt.",
-        "tester_not_reported": "Der Tester hat noch nicht berichtet."
+        "tester_not_reported": "Der Tester hat noch nicht berichtet.",
+        "verified_by_committed_tests": "Diese Pipeline hat bewusst keinen Test-Schritt: Die Änderung ist durch Tests abgedeckt, die zusammen mit ihr committet wurden und in der CI laufen."
       }
     },
     "visuals": {

package/i18n/locales/en.json

@@ -4167,7 +4167,7 @@
       "bugFishing": {
         "heading": "Bug-fishing fix pipeline",
         "body": "The pipeline a bug-fix task runs when you mark a finding from a bug-fishing expedition. Each marked finding becomes its own task on this pipeline; whoever marks it can override the choice for one batch.",
-        "builtInDefault": "Use the built-in bug-fix preset"
+        "builtInDefault": "Use the platform default (the test-verified bug-fix preset)"
       }
     },
     "localModelEndpoints": {
@@ -5216,9 +5216,16 @@
     "title": "Assistant",
     "intro": "Describe what you want done and the assistant performs it on the board: declare a dependency between two services, add a service from a repository URL, or file a task from a tracker issue.",
     "unavailable": "No model is configured on this deployment, so the assistant cannot read a request. Configure a model provider to enable it.",
+    "reading": "Checking what the assistant can do here…",
+    "unreadable": "Could not check what the assistant can do here, so the request box is hidden for now. Try again in a moment.",
+    "noActions": "This deployment's assistant has no actions configured, so there is nothing it can perform. Configure its actions to enable it.",
+    "@noActions": {
+      "description": "Shown in place of the request box when the deployment wired a model but registered no ACTIONS for the assistant to choose from: the operations it can perform on the board, not buttons in the interface. Distinct from the no-model case above."
+    },
     "placeholder": "e.g. the checkout service depends on the payments service",
     "submit": "Run",
     "submitHint": "Ctrl+Enter, or Cmd+Enter on a Mac",
+    "tooLong": "That request is {length} characters and the assistant reads up to {limit}. Shorten it and run again.",
     "examplesTitle": "What you can ask",
     "showOnBoard": "Show on board",
     "declined": "None of the assistant's actions match that request. It can declare a dependency between two services, add a service from a repository URL, or file a task from a tracker issue.",
@@ -6663,7 +6670,8 @@
       },
       "gap": {
         "no_tester_step": "This pipeline has no tester step, so nothing was exercised.",
-        "tester_not_reported": "The tester has not reported yet."
+        "tester_not_reported": "The tester has not reported yet.",
+        "verified_by_committed_tests": "This pipeline has no tester step by design: the change is covered by tests committed alongside it, which CI runs."
       }
     },
     "visuals": {

package/i18n/locales/es.json

@@ -3861,7 +3861,7 @@
       "bugFishing": {
         "heading": "Pipeline de corrección de la pesca de errores",
         "body": "La pipeline con la que se ejecuta una tarea de corrección cuando marca un hallazgo de una pesca de errores. Cada hallazgo marcado se convierte en su propia tarea sobre esta pipeline; quien lo marca puede cambiar la elección para un lote.",
-        "builtInDefault": "Usar la plantilla de corrección integrada"
+        "builtInDefault": "Usar el valor predeterminado de la plataforma (el preset de corrección verificada por pruebas)"
       }
     },
     "localModelEndpoints": {
@@ -5031,9 +5031,13 @@
     "title": "Asistente",
     "intro": "Describe lo que quieres hacer y el asistente lo ejecuta en el tablero: declarar una dependencia entre dos servicios, añadir un servicio a partir de la URL de un repositorio o crear una tarea desde una incidencia del rastreador.",
     "unavailable": "Este despliegue no tiene ningún modelo configurado, así que el asistente no puede leer una petición. Configura un proveedor de modelos para habilitarlo.",
+    "reading": "Comprobando qué puede hacer el asistente aquí…",
+    "unreadable": "No se pudo comprobar qué puede hacer el asistente aquí, así que por ahora el cuadro de solicitud está oculto. Vuelve a intentarlo en un momento.",
+    "noActions": "El asistente de este despliegue no tiene ninguna acción configurada, así que no puede realizar nada. Configura sus acciones para habilitarlo.",
     "placeholder": "p. ej. el servicio de checkout depende del servicio de pagos",
     "submit": "Ejecutar",
     "submitHint": "Ctrl+Intro, o Cmd+Intro en un Mac",
+    "tooLong": "Esa solicitud tiene {length} caracteres y el asistente lee hasta {limit}. Acórtala y vuelve a ejecutarla.",
     "examplesTitle": "Qué puedes pedir",
     "showOnBoard": "Ver en el tablero",
     "declined": "Ninguna acción del asistente encaja con esa petición. Puede declarar una dependencia entre dos servicios, añadir un servicio a partir de la URL de un repositorio o crear una tarea desde una incidencia del rastreador.",
@@ -6341,7 +6345,8 @@
       },
       "gap": {
         "no_tester_step": "Esta canalización no tiene paso de pruebas, así que no se ejercitó nada.",
-        "tester_not_reported": "El tester aún no ha informado."
+        "tester_not_reported": "El tester aún no ha informado.",
+        "verified_by_committed_tests": "Esta canalización no tiene paso de pruebas a propósito: el cambio está cubierto por pruebas incluidas junto a él, que ejecuta la CI."
       }
     },
     "visuals": {

package/i18n/locales/fr.json

@@ -3861,7 +3861,7 @@
       "bugFishing": {
         "heading": "Pipeline de correction de la pêche aux bogues",
         "body": "La pipeline sur laquelle s'exécute une tâche de correction lorsque vous marquez une constatation issue d'une pêche aux bogues. Chaque constatation marquée devient sa propre tâche sur cette pipeline ; la personne qui marque peut changer ce choix pour un lot.",
-        "builtInDefault": "Utiliser le préréglage de correction intégré"
+        "builtInDefault": "Utiliser la valeur par défaut de la plateforme (le préréglage de correction vérifiée par des tests)"
       }
     },
     "localModelEndpoints": {
@@ -5031,9 +5031,13 @@
     "title": "Assistant",
     "intro": "Décrivez ce que vous voulez faire et l'assistant l'exécute sur le tableau : déclarer une dépendance entre deux services, ajouter un service à partir de l'URL d'un dépôt, ou créer une tâche à partir d'un ticket.",
     "unavailable": "Aucun modèle n'est configuré sur ce déploiement, l'assistant ne peut donc pas lire une demande. Configurez un fournisseur de modèles pour l'activer.",
+    "reading": "Vérification de ce que l'assistant peut faire ici…",
+    "unreadable": "Impossible de vérifier ce que l'assistant peut faire ici, le champ de demande est donc masqué pour l'instant. Réessayez dans un instant.",
+    "noActions": "Aucune action n'est configurée pour l'assistant de ce déploiement, il ne peut donc rien exécuter. Configurez ses actions pour l'activer.",
     "placeholder": "ex. le service checkout dépend du service paiements",
     "submit": "Exécuter",
     "submitHint": "Ctrl+Entrée, ou Cmd+Entrée sur un Mac",
+    "tooLong": "Cette demande fait {length} caractères et l'assistant en lit {limit} au maximum. Raccourcissez-la puis relancez.",
     "examplesTitle": "Ce que vous pouvez demander",
     "showOnBoard": "Afficher sur le tableau",
     "declined": "Aucune action de l'assistant ne correspond à cette demande. Il peut déclarer une dépendance entre deux services, ajouter un service à partir de l'URL d'un dépôt, ou créer une tâche à partir d'un ticket.",
@@ -6341,7 +6345,8 @@
       },
       "gap": {
         "no_tester_step": "Ce pipeline ne comporte aucune étape de test, rien n'a donc été exercé.",
-        "tester_not_reported": "Le testeur n'a pas encore rendu son rapport."
+        "tester_not_reported": "Le testeur n'a pas encore rendu son rapport.",
+        "verified_by_committed_tests": "Ce pipeline ne comporte volontairement aucune étape de test : le changement est couvert par des tests livrés avec lui, que la CI exécute."
       }
     },
     "visuals": {

package/i18n/locales/he.json

@@ -4003,7 +4003,7 @@
       "bugFishing": {
         "heading": "צינור התיקון של ציד הבאגים",
         "body": "הצינור שבו רצה משימת תיקון כאשר אתם מסמנים ממצא מציד באגים. כל ממצא מסומן הופך למשימה נפרדת בצינור הזה; מי שמסמן יכול לשנות את הבחירה עבור אצווה אחת.",
-        "builtInDefault": "להשתמש בתבנית תיקון הבאגים המובנית"
+        "builtInDefault": "להשתמש בברירת המחדל של הפלטפורמה (ערכת תיקון הבאגים המאומתת בבדיקות)"
       }
     },
     "localModelEndpoints": {
@@ -5031,9 +5031,13 @@
     "title": "עוזר",
     "intro": "תארו מה צריך לקרות והעוזר יבצע זאת על הלוח: להצהיר על תלות בין שני שירותים, להוסיף שירות מכתובת מאגר או לפתוח משימה מתקלה במעקב.",
     "unavailable": "לא הוגדר מודל בפריסה הזו, לכן העוזר אינו יכול לקרוא בקשה. הגדירו ספק מודלים כדי להפעיל אותו.",
+    "reading": "בודקים מה העוזר יכול לעשות כאן…",
+    "unreadable": "לא הצלחנו לבדוק מה העוזר יכול לעשות כאן, ולכן שדה הבקשה מוסתר בשלב זה. נסו שוב בעוד רגע.",
+    "noActions": "לא הוגדרו פעולות לעוזר בפריסה הזו, ולכן אין לו מה לבצע. הגדירו את הפעולות שלו כדי להפעיל אותו.",
     "placeholder": "למשל: שירות ה-checkout תלוי בשירות התשלומים",
     "submit": "הרץ",
     "submitHint": "Ctrl+Enter, וב-Mac Cmd+Enter",
+    "tooLong": "הבקשה הזאת באורך {length} תווים, והעוזר קורא עד {limit}. קצרו אותה והפעילו שוב.",
     "examplesTitle": "מה אפשר לבקש",
     "showOnBoard": "הצג על הלוח",
     "declined": "אף פעולה של העוזר אינה מתאימה לבקשה הזו. הוא יכול להצהיר על תלות בין שני שירותים, להוסיף שירות מכתובת מאגר או לפתוח משימה מתקלה במעקב.",
@@ -6341,7 +6345,8 @@
       },
       "gap": {
         "no_tester_step": "בצינור הזה אין שלב בדיקות, ולכן שום דבר לא הופעל.",
-        "tester_not_reported": "הבודק עדיין לא דיווח."
+        "tester_not_reported": "הבודק עדיין לא דיווח.",
+        "verified_by_committed_tests": "בצינור הזה אין שלב בדיקות במכוון: השינוי מכוסה בבדיקות שנמסרו לצדו, וה-CI מריצה אותן."
       }
     },
     "visuals": {