@cat-factory/app 0.298.0 → 0.300.0

package/app/stores/consensus.ts

@@ -30,8 +30,13 @@ export const useConsensusStore = defineStore('consensus', () => {
     return loading.value.has(blockId)
   }
 
+  /**
+   * Write one block's session into the cache, IN PLACE: per-key, never a whole-record clone.
+   * `sessions` is a deep reactive ref, so replacing the record retriggered every consumer keyed on
+   * an UNCHANGED block; assigning the key retriggers only the block that actually changed.
+   */
   function store(session: ConsensusSession) {
-    sessions.value = { ...sessions.value, [session.blockId]: session }
+    sessions.value[session.blockId] = session
   }
 
   /** Patch the cache from a live `consensus` stream event (newest wins per block). */
@@ -62,7 +67,7 @@ export const useConsensusStore = defineStore('consensus', () => {
       if (session) {
         if (!existing || session.updatedAt >= existing.updatedAt) store(session)
       } else if (existing === undefined) {
-        sessions.value = { ...sessions.value, [blockId]: null }
+        sessions.value[blockId] = null
       }
     } catch {
       // Consensus off / no session — leave the cache as-is; the window shows its empty state.

package/app/stores/docInterview.ts

@@ -30,7 +30,9 @@ export const useDocInterviewStore = defineStore('docInterview', () => {
   function upsert(session: DocInterviewSession) {
     const existing = byBlock.value[session.blockId]
     if (existing && existing.updatedAt > session.updatedAt) return
-    byBlock.value = { ...byBlock.value, [session.blockId]: session }
+    // Per-key, never a whole-record clone: `byBlock` is a deep reactive ref, so replacing the
+    // record retriggered every consumer keyed on an UNCHANGED block.
+    byBlock.value[session.blockId] = session
   }
 
   /** Re-fetch one block's session (the interview window's load path). */

package/app/stores/initiative.ts

@@ -96,7 +96,10 @@ export const useInitiativesStore = defineStore('initiatives', () => {
   function upsert(initiative: Initiative) {
     const existing = byBlock.value[initiative.blockId]
     if (existing && existing.rev > initiative.rev) return
-    byBlock.value = { ...byBlock.value, [initiative.blockId]: initiative }
+    // Per-key, never a whole-record clone: `byBlock` is a deep reactive ref, so replacing the
+    // record retriggered every consumer keyed on an UNCHANGED block. {@link hydrate} still
+    // replaces it wholesale, because a snapshot is authoritative for EXISTENCE.
+    byBlock.value[initiative.blockId] = initiative
   }
 
   /**

package/app/stores/notifications.ts

@@ -16,8 +16,8 @@ import { useWorkspaceStore } from '~/stores/workspace'
  * Open, human-actionable notifications surfaced on the board (a PR awaiting a
  * merge decision, a completed pipeline awaiting confirmation, CI that gave up).
  * Hydrated from the workspace snapshot and patched live by the `notification`
- * WorkspaceEvent (see `useWorkspaceStream`). The board renders an inbox + a
- * per-block badge from `open` / `byBlock`.
+ * WorkspaceEvent (see `useWorkspaceStream`). The board renders an inbox from `open`, and the
+ * per-block review-wait stamps the swimlanes need from {@link reviewDebtByBlock}.
  */
 export const useNotificationsStore = defineStore('notifications', () => {
   const api = useApi()
@@ -110,16 +110,6 @@ export const useNotificationsStore = defineStore('notifications', () => {
     upsertOpen(notification)
   }
 
-  /** Open notifications for a given block (for the board card badge). */
-  const byBlock = computed<Record<string, Notification[]>>(() => {
-    const map: Record<string, Notification[]> = {}
-    for (const n of open.value) {
-      if (!n.blockId) continue
-      ;(map[n.blockId] ??= []).push(n)
-    }
-    return map
-  })
-
   /**
    * Per-block "waiting since", derived from the open review-wait cards by the same
    * `collectReviewDebt` the backend's friction check uses. It is the fallback source for the park
@@ -213,7 +203,6 @@ export const useNotificationsStore = defineStore('notifications', () => {
     hydrate,
     hydrateBaseline,
     upsert,
-    byBlock,
     reviewDebtByBlock,
     count,
     act,

package/app/stores/perKeyWrites.spec.ts

@@ -0,0 +1,168 @@
+import { describe, it, expect } from 'vitest'
+import { computed } from 'vue'
+import type { BrainstormSession } from '~/types/brainstorm'
+import type { ClarityReview } from '~/types/clarity'
+import type { ConsensusSession } from '~/types/consensus'
+import type { DocInterviewSession, Initiative } from '~/types/domain'
+import type { RequirementReview } from '~/types/requirements'
+import { useBrainstormStore } from '~/stores/brainstorm'
+import { useClarityStore } from '~/stores/clarity'
+import { useConsensusStore } from '~/stores/consensus'
+import { useDocInterviewStore } from '~/stores/docInterview'
+import { useInitiativesStore } from '~/stores/initiative'
+import { useRequirementsStore } from '~/stores/requirements'
+
+// The review-family stores all hold a `Record<blockId, T>` in a DEEP reactive ref and all patch it
+// from a live stream event. `x.value = { ...x.value, [id]: v }` is a write to the REF, a dependency
+// every reader shares whatever key it reads, so one event woke every card on the board;
+// `x.value[id] = v` keeps the invalidation on the key that changed. The rule is stated once in
+// `frontend/app/README.md` ("A record keyed by block id is written PER KEY, never replaced").
+//
+// One table rather than six near-identical specs, because the property is one property and a store
+// that JOINS this family should have exactly one obvious place to be added. Each row asserts the
+// two halves that can regress independently: an event for another block does not invalidate this
+// block's reader, and a FIRST write still reaches a reader that read the key while it was absent
+// (Vue tracks a missing-key read, which is what makes the in-place write safe at all).
+
+interface StoreCase {
+  name: string
+  /** Patch the store from a live event for `blockId`, tagged with `mark` so the read can see it. */
+  write: (blockId: string, mark: string) => void
+  /** What a card renders off that block: the tag, or null when the store holds nothing. */
+  read: (blockId: string) => string | null
+}
+
+const cases: StoreCase[] = [
+  {
+    name: 'requirements',
+    write: (blockId, mark) => {
+      useRequirementsStore().upsert({
+        id: mark,
+        blockId,
+        status: 'ready',
+        iteration: 1,
+        maxIterations: 3,
+        items: [],
+        updatedAt: 1,
+      } as unknown as RequirementReview)
+    },
+    read: (blockId) => useRequirementsStore().reviewFor(blockId)?.id ?? null,
+  },
+  {
+    name: 'clarity',
+    write: (blockId, mark) => {
+      useClarityStore().upsert({
+        id: mark,
+        blockId,
+        status: 'ready',
+        items: [],
+        updatedAt: 1,
+      } as unknown as ClarityReview)
+    },
+    read: (blockId) => useClarityStore().reviewFor(blockId)?.id ?? null,
+  },
+  {
+    name: 'brainstorm',
+    // Keyed by block+STAGE, so a block legitimately holds one live session per stage; the
+    // invalidation still has to land on the one composite key that changed.
+    write: (blockId, mark) => {
+      useBrainstormStore().upsert({
+        id: mark,
+        blockId,
+        stage: 'requirements',
+        status: 'ready',
+        options: [],
+        updatedAt: 1,
+      } as unknown as BrainstormSession)
+    },
+    read: (blockId) => useBrainstormStore().sessionFor(blockId, 'requirements')?.id ?? null,
+  },
+  {
+    name: 'consensus',
+    write: (blockId, mark) => {
+      useConsensusStore().upsert({
+        id: mark,
+        blockId,
+        status: 'complete',
+        participants: [],
+        rounds: [],
+        synthesis: null,
+        createdAt: 1,
+        updatedAt: 1,
+      } as unknown as ConsensusSession)
+    },
+    read: (blockId) => useConsensusStore().sessionFor(blockId)?.id ?? null,
+  },
+  {
+    name: 'docInterview',
+    write: (blockId, mark) => {
+      useDocInterviewStore().upsert({
+        id: mark,
+        blockId,
+        status: 'awaiting_answers',
+        round: 1,
+        maxRounds: 3,
+        qa: [],
+        createdAt: 1,
+        updatedAt: 1,
+      } as unknown as DocInterviewSession)
+    },
+    read: (blockId) => useDocInterviewStore().forBlock(blockId)?.id ?? null,
+  },
+  {
+    name: 'initiative',
+    write: (blockId, mark) => {
+      useInitiativesStore().upsert({
+        id: mark,
+        blockId,
+        slug: 'i',
+        title: 'I',
+        rev: 1,
+      } as unknown as Initiative)
+    },
+    read: (blockId) => useInitiativesStore().forBlock(blockId)?.id ?? null,
+  },
+]
+
+describe.each(cases)('$name store per-key writes', ({ write, read }) => {
+  it('an event for one block does not invalidate a consumer reading another', () => {
+    write('blk-a', 'a1')
+
+    let evaluations = 0
+    const forA = computed(() => {
+      evaluations++
+      return read('blk-a')
+    })
+    expect(forA.value).toBe('a1')
+    expect(evaluations).toBe(1)
+
+    // A brand-new key, then a rewrite of that existing one: neither is about `blk-a`.
+    write('blk-b', 'b1')
+    expect(forA.value).toBe('a1')
+    write('blk-b', 'b2')
+    expect(forA.value).toBe('a1')
+    expect(evaluations).toBe(1)
+
+    // The block's OWN event still reaches it.
+    write('blk-a', 'a2')
+    expect(forA.value).toBe('a2')
+    expect(evaluations).toBe(2)
+  })
+
+  it('a FIRST write reaches a reader that read the key while it was absent', () => {
+    // The half an in-place write could plausibly lose: the reader tracked a key that did not
+    // exist. Vue tracks a missing-key read, so ADDING the key notifies it. Without this the
+    // window a card opens before its first event would render its empty state forever.
+    let evaluations = 0
+    const forC = computed(() => {
+      evaluations++
+      return read('blk-c')
+    })
+    expect(forC.value).toBeNull()
+    expect(evaluations).toBe(1)
+
+    write('blk-c', 'c1')
+    expect(forC.value).toBe('c1')
+    expect(evaluations).toBe(2)
+  })
+})

package/app/stores/requirements/recommendations.ts

@@ -20,6 +20,31 @@ export interface RecommendationCommandContext {
   hasPendingRecommendations: (blockId: string) => boolean
 }
 
+/**
+ * Whether the Requirement Writer is still producing recommendations for THIS review: a `pending`
+ * placeholder exists. Server-derived, so the "Recommending…" state survives the window closing
+ * and a page reload; the client-local `recommending` set only covers the request round-trip.
+ *
+ * Memoised on the review OBJECT, like the settlement tallies next door, and for the same reason:
+ * the store REPLACES the review on every write, so identity self-invalidates and a superseded
+ * review is collected along with its answer.
+ *
+ * Per REVIEW rather than per record, which is the whole point. `backgroundStage` asks this on the
+ * per-CARD path, and a `computed` over the `reviews` record tracks the ref plus every key in it,
+ * so one review event would re-evaluate every card's stage, the fan-out the per-key write exists
+ * to remove. Reading one key depends on one key.
+ */
+const pendingByReview = new WeakMap<RequirementReview, boolean>()
+
+export function awaitsRecommendations(review: RequirementReview): boolean {
+  let pending = pendingByReview.get(review)
+  if (pending === undefined) {
+    pending = (review.recommendations ?? []).some((r) => r.status === 'pending')
+    pendingByReview.set(review, pending)
+  }
+  return pending
+}
+
 /** Ask for, accept, reject and re-request the Requirement Writer's suggested answers. */
 export function createRecommendationCommands(ctx: RecommendationCommandContext) {
   const { api, workspace, recommending, withFlag, store, hasPendingRecommendations } = ctx

package/app/stores/requirements.spec.ts

@@ -1,5 +1,6 @@
 import { describe, it, expect, beforeEach, vi } from 'vitest'
-import type { RequirementReview } from '~/types/requirements'
+import { computed } from 'vue'
+import type { RequirementRecommendation, RequirementReview } from '~/types/requirements'
 import { useRequirementsStore } from '~/stores/requirements'
 import { useWorkspaceStore } from '~/stores/workspace'
 
@@ -18,6 +19,20 @@ function review(over: Partial<RequirementReview> = {}): RequirementReview {
   } as RequirementReview
 }
 
+/** A `pending` Writer placeholder: the state `backgroundStage` reads as "recommending". */
+function pendingRecommendation(id: string): RequirementRecommendation {
+  return {
+    id,
+    sourceFinding: { title: 'f', detail: 'd', itemId: 'i1' },
+    recommendedText: '',
+    status: 'pending',
+    note: null,
+    groundedInFragment: null,
+    createdAt: 1,
+    updatedAt: 1,
+  } as RequirementRecommendation
+}
+
 describe('requirements store load() loading flag', () => {
   beforeEach(() => {
     // The store resolves its workspace id from the workspace store at call time.
@@ -113,3 +128,76 @@ describe('requirements store live-event upsert guard', () => {
     expect(store.reviewFor('b1')?.id).toBe('rr2')
   })
 })
+
+describe('requirements store per-key writes', () => {
+  it('an event for one block does not invalidate a consumer reading another', () => {
+    // Every card on the board reads its OWN block's review (the "Recommending…"/gate badge), so
+    // one review event used to wake every card: the store replaced the whole record, which is a
+    // write to the ref itself and therefore a dependency every reader shares. Writing the key
+    // keeps the invalidation on the block that changed.
+    const store = useRequirementsStore()
+    store.upsert(review({ id: 'rr-a', blockId: 'blk-a', updatedAt: 1 }))
+
+    let evaluations = 0
+    const forA = computed(() => {
+      evaluations++
+      return store.reviewFor('blk-a')?.id ?? null
+    })
+    expect(forA.value).toBe('rr-a')
+    expect(evaluations).toBe(1)
+
+    // A brand-new key, then a rewrite of an existing one: neither is about `blk-a`.
+    store.upsert(review({ id: 'rr-b', blockId: 'blk-b', updatedAt: 1 }))
+    expect(forA.value).toBe('rr-a')
+    store.upsert(review({ id: 'rr-b', blockId: 'blk-b', updatedAt: 2 }))
+    expect(forA.value).toBe('rr-a')
+    expect(evaluations).toBe(1)
+
+    // The block's OWN event still reaches it.
+    store.upsert(review({ id: 'rr-a2', blockId: 'blk-a', updatedAt: 2 }))
+    expect(forA.value).toBe('rr-a2')
+    expect(evaluations).toBe(2)
+  })
+
+  it('the per-card STAGE read depends on one block too, pending recommendations included', () => {
+    // `backgroundStage` is the read every card actually makes (TaskCard/BlockNode via
+    // `useReviewStage`), and it is the one the per-key write alone does not fix: while the pending
+    // -recommendation answer came from a `computed` over the whole `reviews` record, that computed
+    // tracked every key, so one event still re-evaluated the stage of every card on the board.
+    // Answering off the block's own review object is what closes it.
+    const store = useRequirementsStore()
+    store.upsert(review({ id: 'rr-a', blockId: 'blk-a', updatedAt: 1 }))
+
+    let evaluations = 0
+    const stageForA = computed(() => {
+      evaluations++
+      return store.backgroundStage('blk-a')
+    })
+    expect(stageForA.value).toBeNull()
+    expect(evaluations).toBe(1)
+
+    // Another block starts recommending: not this card's business.
+    store.upsert(
+      review({
+        id: 'rr-b',
+        blockId: 'blk-b',
+        updatedAt: 1,
+        recommendations: [pendingRecommendation('rec-1')],
+      }),
+    )
+    expect(stageForA.value).toBeNull()
+    expect(evaluations).toBe(1)
+
+    // This block's own placeholder still surfaces the working state.
+    store.upsert(
+      review({
+        id: 'rr-a2',
+        blockId: 'blk-a',
+        updatedAt: 2,
+        recommendations: [pendingRecommendation('rec-2')],
+      }),
+    )
+    expect(stageForA.value).toBe('recommending')
+    expect(evaluations).toBe(2)
+  })
+})

package/app/stores/requirements.ts

@@ -1,5 +1,5 @@
 import { defineStore } from 'pinia'
-import { computed, ref } from 'vue'
+import { ref } from 'vue'
 import type {
   RequirementReview,
   ResolveRequirementsExceededChoice,
@@ -16,7 +16,10 @@ import {
   canProceed,
   openCount,
 } from '~/stores/requirements/settlement'
-import { createRecommendationCommands } from '~/stores/requirements/recommendations'
+import {
+  awaitsRecommendations,
+  createRecommendationCommands,
+} from '~/stores/requirements/recommendations'
 
 /**
  * Requirements-review state. On the pipeline path the reviewer runs as the first gate
@@ -55,24 +58,16 @@ export const useRequirementsStore = defineStore('requirements', () => {
   function reviewFor(blockId: string): RequirementReview | null {
     return reviews.value[blockId] ?? null
   }
-  /** Whether the Requirement Writer is still producing recommendations for a block (a `pending`
-   * placeholder exists). Server-derived, so the "Recommending…" state survives the window closing
-   * and a page reload — the client-local `recommending` set only covers the request round-trip. */
   /**
-   * Blocks whose stored review still carries a `pending` recommendation placeholder, derived once
-   * per change to `reviews` rather than per call. {@link backgroundStage} asks this on the per-CARD
-   * path, so as a function it re-scanned one review's recommendation list for every card on the
-   * board on every event.
+   * Whether the Requirement Writer is still producing recommendations for a block. Reads ONE key
+   * and answers off the review object itself ({@link awaitsRecommendations} memoises the scan on
+   * that object), so a card asking about its own block depends only on its own block. A `computed`
+   * over the whole record would be the fan-out again: it tracks every key, so one review event
+   * would re-evaluate the stage of every card on the board.
    */
-  const blocksAwaitingRecommendations = computed(() => {
-    const blocks = new Set<string>()
-    for (const [blockId, review] of Object.entries(reviews.value)) {
-      if ((review?.recommendations ?? []).some((r) => r.status === 'pending')) blocks.add(blockId)
-    }
-    return blocks
-  })
   function hasPendingRecommendations(blockId: string): boolean {
-    return blocksAwaitingRecommendations.value.has(blockId)
+    const review = reviews.value[blockId]
+    return review ? awaitsRecommendations(review) : false
   }
   /**
    * The async background stage a block's review is in, or null. While the driver folds the
@@ -96,8 +91,16 @@ export const useRequirementsStore = defineStore('requirements', () => {
     return incorporating.value.has(reviewId)
   }
 
+  /**
+   * Write one block's review into the cache, IN PLACE.
+   *
+   * Per-key, never a whole-record clone: `reviews` is a deep reactive ref, so a consumer reading
+   * `reviews[someBlockId]` depends on THAT key. Replacing the record retriggered every one of
+   * them (a card, a badge, an inspector panel for an untouched block) on every event; assigning
+   * the key retriggers only the consumers of the block that actually changed.
+   */
   function store(review: RequirementReview) {
-    reviews.value = { ...reviews.value, [review.blockId]: review }
+    reviews.value[review.blockId] = review
   }
 
   /** Patch the cache from a live `requirements` stream event (newest wins per block). */
@@ -139,7 +142,9 @@ export const useRequirementsStore = defineStore('requirements', () => {
       try {
         const review = await api.getRequirementReview(workspace.requireId(), blockId)
         available.value = true
-        reviews.value = { ...reviews.value, [blockId]: review }
+        // Written by key like `store()`, and directly because a load resolving to "none exists"
+        // caches a null the getter reads as "fetched, absent".
+        reviews.value[blockId] = review
       } catch {
         // 503 (feature off) or any error → hide the UI entry points.
         available.value = false

package/app/stores/ui/modals.ts

@@ -216,6 +216,11 @@ function createDocumentTaskModals(resetHubReturn: ResetHubReturn) {
   // the create-in target AND scopes the issue search to the frame's linked repo.
   // Null → the unscoped "import an issue" surface (workspace-wide search).
   const taskImport = ref<{ source: TaskSourceKind | null; containerId: string | null } | null>(null)
+  // In-app assistant: the prompt box that routes one sentence to one board action. It carries no
+  // subject (a turn resolves every name it needs from the board itself), so a plain flag says
+  // everything the host needs to know.
+  const assistantOpen = ref(false)
+
   // Bug hunt: pick a tracker + one of its boards, rank its open unassigned bugs, adopt one.
   // `containerId` (a service frame or module) preselects where an adopted bug lands; null →
   // opened standalone, and the modal offers every container on the board.
@@ -293,6 +298,13 @@ function createDocumentTaskModals(resetHubReturn: ResetHubReturn) {
   function closeTaskImport() {
     taskImport.value = null
   }
+  function openAssistant() {
+    resetHubReturn()
+    assistantOpen.value = true
+  }
+  function closeAssistant() {
+    assistantOpen.value = false
+  }
   function openBugHunt(source: TaskSourceKind | null = null, containerId: string | null = null) {
     resetHubReturn()
     bugHunt.value = { source, containerId }
@@ -341,6 +353,7 @@ function createDocumentTaskModals(resetHubReturn: ResetHubReturn) {
     spawnPreview,
     taskConnect,
     taskImport,
+    assistantOpen,
     bugHunt,
     startFromDesign,
     addTaskContainerId,
@@ -360,6 +373,8 @@ function createDocumentTaskModals(resetHubReturn: ResetHubReturn) {
     closeTaskConnect,
     openTaskImport,
     closeTaskImport,
+    openAssistant,
+    closeAssistant,
     openBugHunt,
     closeBugHunt,
     openStartFromDesign,

package/app/types/assistant.ts

@@ -0,0 +1,24 @@
+// ---------------------------------------------------------------------------
+// The in-app assistant: one natural-language prompt, one action the platform performs on the
+// person's behalf (declare a service dependency, add a service from a repository URL, file a task
+// from a tracker issue).
+//
+// A turn answers with DATA, never with model prose: the outcome variant carries the ids and names
+// of what was touched, or the machine-readable reason it could not act, and the SPA renders every
+// sentence from those members through the i18n catalog. All wire shapes are sourced from
+// @cat-factory/contracts (single source of truth).
+// ---------------------------------------------------------------------------
+
+export type {
+  AssistantActionId,
+  AssistantActionResult,
+  AssistantAnswer,
+  AssistantArguments,
+  AssistantCapability,
+  AssistantClarificationReason,
+  AssistantDeclineReason,
+  AssistantOutcome,
+  AssistantServiceRef,
+  AssistantTurn,
+  AssistantTurnInput,
+} from '@cat-factory/contracts'

package/app/types/domain.ts

@@ -220,6 +220,7 @@ export type * from './skills'
 export type * from './foundationalServices'
 export type * from './documents'
 export type * from './tasks'
+export type * from './assistant'
 export type * from './bugHunt'
 export type * from './bootstrap'
 export type * from './envConfigRepair'

package/i18n/locales/de.json

@@ -2712,6 +2712,7 @@
       },
       "cmd": {
         "newPipeline": "Eine Pipeline bauen",
+        "assistant": "Assistenten öffnen",
         "addFromRepo": "Service aus vorhandenem Repo hinzufügen",
         "bootstrapRepo": "Ein neues Repo bootstrappen",
         "githubManage": "GitHub-Verbindung verwalten",
@@ -2739,6 +2740,7 @@
       },
       "keywords": {
         "newPipeline": "pipeline agents chain",
+        "assistant": "ki assistent fragen eingabe für mich erledigen",
         "addFromRepo": "github import existing",
         "bootstrapRepo": "scaffold create reference architecture",
         "github": "git repos pull requests issues",
@@ -4514,6 +4516,49 @@
       "missingBoard": "Wähle das Board aus, auf dem gesucht werden soll."
     }
   },
+  "assistant": {
+    "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.",
+    "placeholder": "z. B. der Checkout-Service hängt vom Payments-Service ab",
+    "submit": "Ausführen",
+    "submitHint": "Strg+Enter, auf dem Mac Cmd+Enter",
+    "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.",
+    "actions": {
+      "declare-service-dependency": {
+        "label": "Service-Abhängigkeit erklären",
+        "example": "der Checkout-Service hängt vom Payments-Service ab"
+      },
+      "add-service-from-repo": {
+        "label": "Service aus einem Repository hinzufügen",
+        "example": "füge https://github.com/acme/payments als Service hinzu"
+      },
+      "create-task-from-issue": {
+        "label": "Aufgabe aus einem Ticket anlegen",
+        "example": "erstelle eine Aufgabe aus https://github.com/acme/payments/issues/12"
+      }
+    },
+    "done": {
+      "dependencyDeclared": "{consumer} hängt jetzt von {provider} ab, beide werden also gestartet, wenn {consumer} getestet wird.",
+      "dependencyAlready": "{consumer} hängt bereits von {provider} ab, es hat sich nichts geändert.",
+      "serviceAdded": "{service} hinzugefügt, gestützt auf {repo}.",
+      "serviceMounted": "{repo} liegt bereits einem Service dieser Organisation zugrunde, deshalb wurde {service} auf dieses Board gelegt statt neu angelegt.",
+      "taskCreated": "{issue} als „{task}“ unter {service} angelegt."
+    },
+    "needsInput": {
+      "missing_argument": "In dieser Anfrage fehlt etwas, das der Assistent braucht. Formulieren Sie sie vollständig und versuchen Sie es erneut.",
+      "invalid_argument": "Einer der Werte in dieser Anfrage ist nicht verwendbar. Prüfen Sie ihn und versuchen Sie es erneut.",
+      "unknown_service": "Kein Service auf diesem Board trägt diesen Namen.",
+      "ambiguous_service": "Mehrere Services passen zu diesem Namen. Welchen meinen Sie?",
+      "unknown_repository": "Dieser Workspace hat keine Verbindung zu diesem Repository. Verbinden Sie es zuerst und fragen Sie dann erneut.",
+      "unreadable_repository_url": "Das ist keine Repository-URL, die der Assistent lesen kann. Fügen Sie die Webadresse des Repositorys ein.",
+      "unknown_issue_source": "Kein verbundener Tracker erkennt diesen Ticket-Link. Verbinden Sie zuerst den zugehörigen Tracker.",
+      "ambiguous_issue_source": "Zwei verbundene Tracker erkennen diese Angabe. Fügen Sie stattdessen die vollständige Webadresse des Tickets ein.",
+      "unresolved_issue_service": "Der Assistent konnte nicht erkennen, unter welchem Service das angelegt werden soll. Nennen Sie den Service in Ihrer Anfrage."
+    }
+  },
   "pipeline": {
     "iterationCap": {
       "extraRound": "Noch eine Runde",
@@ -6095,6 +6140,7 @@
     "collapseSidebar": "Seitenleiste einklappen",
     "commandBar": "Suchen oder einen Befehl ausführen…",
     "create": "Erstellen",
+    "assistant": "Assistent",
     "buildPipeline": "Eine Pipeline erstellen",
     "repositories": "Repositories",
     "addFromRepo": "Aus vorhandenem Repo hinzufügen",
@@ -6144,7 +6190,9 @@
         "service_catalog_unreachable": "Das Entwicklerportal dieses Boards hat nicht geantwortet oder eine Antwort geliefert, die diese Plattform nicht lesen kann. Hier ist nichts falsch konfiguriert und keine Änderung hilft: versuche es erneut, sobald das Portal erreichbar ist.",
         "service_catalog_unauthorized": "Das Entwicklerportal hat die gespeicherte Zugangsdaten abgelehnt. Sie wurden wahrscheinlich rotiert oder widerrufen: öffne die Servicekatalog-Einstellungen und trage aktuelle ein.",
         "service_catalog_filter_missing": "Der Entitätsfilter dieser Verbindung konnte nicht gelesen werden, es gibt also nichts zu importieren. Speichere die Servicekatalog-Verbindung erneut, um ihn wiederherzustellen.",
-        "service_catalog_response_too_large": "Das Entwicklerportal hat mit mehr Daten geantwortet, als diese Plattform in einer Antwort aufnimmt. Öffne die Servicekatalog-Einstellungen und senke das Service-Limit oder deaktiviere den Import von Schnittstellendefinitionen, und importiere dann erneut."
+        "service_catalog_response_too_large": "Das Entwicklerportal hat mit mehr Daten geantwortet, als diese Plattform in einer Antwort aufnimmt. Öffne die Servicekatalog-Einstellungen und senke das Service-Limit oder deaktiviere den Import von Schnittstellendefinitionen, und importiere dann erneut.",
+        "assistant_generation_failed": "Der Modellanbieter des Assistenten hat nicht geantwortet. Er ist korrekt konfiguriert und hier muss nichts eingerichtet werden: Versuchen Sie die Anfrage gleich noch einmal.",
+        "assistant_reply_unreadable": "Das Modell des Assistenten hat etwas geantwortet, das diese Plattform nicht als Entscheidung ausführen kann. Eine Umformulierung hilft selten: Wählen Sie in den Modelleinstellungen ein anderes Modell für den Assistenten."
       }
     },
     "reason": {