@cat-factory/app 0.300.1 → 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

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

package/i18n/locales/en.json

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

package/i18n/locales/es.json

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

package/i18n/locales/fr.json

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

package/i18n/locales/he.json

@@ -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": "אף פעולה של העוזר אינה מתאימה לבקשה הזו. הוא יכול להצהיר על תלות בין שני שירותים, להוסיף שירות מכתובת מאגר או לפתוח משימה מתקלה במעקב.",

package/i18n/locales/it.json

@@ -4520,9 +4520,13 @@
     "title": "Assistente",
     "intro": "Descrivi cosa vuoi fare e l'assistente lo esegue sulla bacheca: dichiarare una dipendenza fra due servizi, aggiungere un servizio dall'URL di un repository o creare un'attività da una segnalazione del tracker.",
     "unavailable": "Questo deployment non ha un modello configurato, quindi l'assistente non può leggere una richiesta. Configura un provider di modelli per abilitarlo.",
+    "reading": "Verifica di ciò che l'assistente può fare qui…",
+    "unreadable": "Non è stato possibile verificare ciò che l'assistente può fare qui, quindi per ora il campo della richiesta è nascosto. Riprova tra un momento.",
+    "noActions": "L'assistente di questo deployment non ha azioni configurate, quindi non può eseguire nulla. Configura le sue azioni per abilitarlo.",
     "placeholder": "es. il servizio checkout dipende dal servizio pagamenti",
     "submit": "Esegui",
     "submitHint": "Ctrl+Invio, oppure Cmd+Invio su Mac",
+    "tooLong": "Questa richiesta ha {length} caratteri e l'assistente ne legge al massimo {limit}. Accorciala ed esegui di nuovo.",
     "examplesTitle": "Cosa puoi chiedere",
     "showOnBoard": "Mostra sulla bacheca",
     "declined": "Nessuna azione dell'assistente corrisponde a questa richiesta. Può dichiarare una dipendenza fra due servizi, aggiungere un servizio dall'URL di un repository o creare un'attività da una segnalazione del tracker.",

package/i18n/locales/ja.json

@@ -5031,9 +5031,13 @@
     "title": "アシスタント",
     "intro": "やりたいことを書くと、アシスタントがボード上で実行します。サービス間の依存関係の宣言、リポジトリ URL からのサービス追加、トラッカーのイシューからのタスク作成ができます。",
     "unavailable": "このデプロイメントにはモデルが設定されていないため、アシスタントは依頼を読み取れません。モデルプロバイダーを設定して有効にしてください。",
+    "reading": "ここでアシスタントに何ができるかを確認しています…",
+    "unreadable": "ここでアシスタントに何ができるかを確認できなかったため、入力欄はいまは表示されません。少し待ってからもう一度お試しください。",
+    "noActions": "このデプロイメントのアシスタントにはアクションが設定されていないため、実行できる操作がありません。アクションを設定して有効にしてください。",
     "placeholder": "例: checkout サービスは payments サービスに依存している",
     "submit": "実行",
     "submitHint": "Ctrl+Enter、Mac では Cmd+Enter",
+    "tooLong": "このリクエストは {length} 文字ですが、アシスタントが読めるのは {limit} 文字までです。短くしてから実行してください。",
     "examplesTitle": "依頼できること",
     "showOnBoard": "ボードで表示",
     "declined": "この依頼に合う操作はありません。アシスタントができるのは、2 つのサービス間の依存関係の宣言、リポジトリ URL からのサービス追加、トラッカーのイシューからのタスク作成です。",

package/i18n/locales/pl.json

@@ -5031,9 +5031,13 @@
     "title": "Asystent",
     "intro": "Opisz, co ma zostać zrobione, a asystent wykona to na tablicy: zadeklaruje zależność między dwiema usługami, doda usługę z adresu repozytorium albo utworzy zadanie ze zgłoszenia w trackerze.",
     "unavailable": "W tym wdrożeniu nie skonfigurowano żadnego modelu, więc asystent nie może odczytać prośby. Skonfiguruj dostawcę modeli, aby go włączyć.",
+    "reading": "Sprawdzamy, co asystent może tu zrobić…",
+    "unreadable": "Nie udało się sprawdzić, co asystent może tu zrobić, więc pole żądania jest na razie ukryte. Spróbuj ponownie za chwilę.",
+    "noActions": "Asystent w tym wdrożeniu nie ma skonfigurowanych żadnych akcji, więc nie może nic wykonać. Skonfiguruj jego akcje, aby go włączyć.",
     "placeholder": "np. usługa checkout zależy od usługi płatności",
     "submit": "Uruchom",
     "submitHint": "Ctrl+Enter, na Macu Cmd+Enter",
+    "tooLong": "To żądanie ma {length} znaków, a asystent czyta najwyżej {limit}. Skróć je i uruchom ponownie.",
     "examplesTitle": "O co możesz poprosić",
     "showOnBoard": "Pokaż na tablicy",
     "declined": "Żadne działanie asystenta nie pasuje do tej prośby. Może zadeklarować zależność między dwiema usługami, dodać usługę z adresu repozytorium albo utworzyć zadanie ze zgłoszenia w trackerze.",

package/i18n/locales/tr.json

@@ -5031,9 +5031,13 @@
     "title": "Asistan",
     "intro": "Ne yapılmasını istediğinizi yazın, asistan bunu panoda gerçekleştirsin: iki servis arasında bağımlılık tanımlamak, bir depo adresinden servis eklemek ya da bir izleyici kaydından görev oluşturmak.",
     "unavailable": "Bu kurulumda yapılandırılmış bir model yok, bu yüzden asistan isteği okuyamıyor. Etkinleştirmek için bir model sağlayıcısı yapılandırın.",
+    "reading": "Asistanın burada neler yapabileceği denetleniyor…",
+    "unreadable": "Asistanın burada neler yapabileceği denetlenemedi, bu yüzden istek alanı şimdilik gizli. Birazdan yeniden deneyin.",
+    "noActions": "Bu kurulumdaki asistan için yapılandırılmış bir eylem yok, bu yüzden hiçbir şey gerçekleştiremiyor. Etkinleştirmek için eylemlerini yapılandırın.",
     "placeholder": "örn. checkout servisi ödemeler servisine bağlıdır",
     "submit": "Çalıştır",
     "submitHint": "Ctrl+Enter, Mac'te Cmd+Enter",
+    "tooLong": "Bu istek {length} karakter, asistan ise en fazla {limit} karakter okuyor. Kısaltıp yeniden çalıştırın.",
     "examplesTitle": "Neler isteyebilirsiniz",
     "showOnBoard": "Panoda göster",
     "declined": "Asistanın hiçbir eylemi bu istekle eşleşmiyor. İki servis arasında bağımlılık tanımlayabilir, bir depo adresinden servis ekleyebilir ya da bir izleyici kaydından görev oluşturabilir.",

package/i18n/locales/uk.json

@@ -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": "Жодна дія асистента не відповідає цьому запиту. Він може оголосити залежність між двома сервісами, додати сервіс за адресою репозиторію або створити завдання з тікета трекера.",