@cat-factory/app 0.259.1 → 0.260.1

package/app/utils/monorepoImport.ts

@@ -0,0 +1,154 @@
+import type { FrameRepoType, FrontendBackendBinding, FrontendConfig } from '~/types/domain'
+
+/**
+ * Planning rules for a monorepo import: turning the picked subdirectories into the frames to
+ * create, and the `frontendConfig` patches those frames owe once they have ids.
+ *
+ * The relationship model already exists: a `frontend` frame's `backendBindings` ARE the
+ * frontend→service board link (`@cat-factory/contracts`'s `frontendBackendBindingSchema`), the
+ * frontend counterpart of a service frame's `serviceConnections`. All this adds is declaring it
+ * at IMPORT time, while the user still has the whole selection in front of them, instead of
+ * making them open the frontend's inspector afterwards and re-pick services one row at a time.
+ *
+ * Pure and frontend-only: the modal is the sole caller, so these rules stay here rather than in
+ * contracts (nothing on the backend has to agree about them, since it sees ordinary frame creates
+ * and ordinary `frontendConfig` patches).
+ */
+
+/**
+ * Whether the import may offer a frontend mark for the directories it is about to create.
+ *
+ * Two conditions, both about the mark meaning something:
+ *
+ * - The picked role is `service`. A backend binding may only point at a `service` frame, so
+ *   marking a frontend among libraries or document repos would wire nothing, and when the role
+ *   already IS `frontend`, every frame is one and singling one out says nothing.
+ * - At least two directories are being CREATED. The mark divides that set into "the frontend" and
+ *   "the backends it talks to"; with one there is no rest to bind to, and the role select above
+ *   already covers importing a lone frontend. The count is of what the add will actually create,
+ *   never of the raw cart: a cart entry whose frame already exists (a retry after a partial
+ *   failure) is filtered out of the import, so counting it would offer a mark that binds nothing.
+ */
+export function canDesignateFrontend(type: FrameRepoType, directoryCount: number): boolean {
+  return type === 'service' && directoryCount >= 2
+}
+
+/** One frame the import will create: its repo subdirectory and the role it takes. */
+export interface MonorepoImportEntry {
+  /** Repo-root-relative subdirectory the frame is pinned to. */
+  directory: string
+  /** The frame's repo role: `frontend` for the marked directory, the picked role for the rest. */
+  type: FrameRepoType
+  /**
+   * Whether this is the ONE directory marked as the frontend for the others, so its config binds
+   * every other frame the import creates.
+   *
+   * Stated here rather than left to be re-derived from `type`, because `type === 'frontend'` does
+   * NOT identify it: when the picked ROLE is `frontend`, every entry carries that type and no mark
+   * was ever on offer (see {@link canDesignateFrontend}), so a type test picks an arbitrary frame
+   * and binds it to a backend set that does not exist.
+   */
+  designatedFrontend: boolean
+}
+
+/**
+ * The frames to create for a monorepo import, in the order the user picked them.
+ *
+ * A `frontendDirectory` is honoured only when the mark would MEAN something, and this is the one
+ * place that decides. Two ways it can be stale, both of which designate nothing rather than
+ * promoting some other frame:
+ *
+ * - The role or the size of the import no longer admits a mark ({@link canDesignateFrontend}), so
+ *   the picker is not even on screen. Enforced here rather than trusted to the caller, because a
+ *   caller that re-derives the condition can drift from it.
+ * - The marked directory is not among the ones being created: it was removed from the cart, or an
+ *   earlier add already created it.
+ */
+export function planMonorepoImport(
+  directories: readonly string[],
+  backendType: FrameRepoType,
+  frontendDirectory: string | undefined,
+): MonorepoImportEntry[] {
+  const marked =
+    canDesignateFrontend(backendType, directories.length) && frontendDirectory !== undefined
+  const frontend = marked && directories.includes(frontendDirectory) ? frontendDirectory : undefined
+  return directories.map((directory) => ({
+    directory,
+    type: directory === frontend ? 'frontend' : backendType,
+    designatedFrontend: directory === frontend,
+  }))
+}
+
+/** A frame the import created, paired with the plan entry it was created from. */
+export interface CreatedMonorepoFrame {
+  /** Id of the block the create call minted. */
+  blockId: string
+  /** The entry that produced it, carrying its role and whether it is the designated frontend. */
+  entry: MonorepoImportEntry
+}
+
+/** One `frontendConfig` write the import owes a frame it created. */
+export interface FrontendConfigPatch {
+  blockId: string
+  config: FrontendConfig
+}
+
+/**
+ * The `frontendConfig` each created `frontend` frame needs, once the create calls have minted
+ * their ids.
+ *
+ * EVERY frontend frame gets one, not only a designated one, because the patch carries two
+ * separable facts:
+ *
+ * - **`directory`, for all of them.** A frame's monorepo subdirectory is a SERVICE-level fact (the
+ *   repo projection's `directory`, which scopes an agent's checkout); the harness's frontend
+ *   install/build/serve reads `frontendConfig.directory` instead, and defaults to the repo root
+ *   when it is absent. So a monorepo frontend whose config does not repeat it builds the wrong
+ *   tree, silently. That is true of every frontend frame an import creates, including a whole cart
+ *   imported under the `frontend` role, where no mark is ever offered. The user picked the
+ *   directory, so it is copied, never guessed.
+ * - **`backendBindings`, for the designated one only.** The mark is what says "these other frames
+ *   are the backends this app talks to"; an undesignated frontend frame is bound to nothing, which
+ *   is the same empty list the inspector would have shown.
+ */
+export function planFrontendConfigPatches(
+  created: readonly CreatedMonorepoFrame[],
+): FrontendConfigPatch[] {
+  const designated = created.find((frame) => frame.entry.designatedFrontend)
+  const backendBlockIds = designated
+    ? created.filter((frame) => frame !== designated).map((frame) => frame.blockId)
+    : []
+  return created
+    .filter((frame) => frame.entry.type === 'frontend')
+    .map((frame) => ({
+      blockId: frame.blockId,
+      config: frontendConfigForImport(
+        frame.entry.directory,
+        frame === designated ? backendBlockIds : [],
+      ),
+    }))
+}
+
+/**
+ * The `frontendConfig` for one created frontend frame: where the app lives in the repo, and one
+ * backend binding per frame it was marked the frontend for.
+ *
+ * **`envVar` is left EMPTY.** The env var a frontend reads for an upstream URL is a fact about the
+ * frontend's own source, which an import that never looks inside the repo cannot know, and
+ * inventing a plausible name (`PUB_API_URL`) would inject a variable nothing reads while looking
+ * configured. Empty is the contract's designed inert state: the job-body builder filters those
+ * bindings out of the injected env, `duplicateBindingEnvVars` ignores them, `frontendOriginsForService`
+ * skips them, and the board still draws the frontend→service edge. What the import DOES know (which
+ * services this frontend talks to) is recorded; the names are left for the inspector's "Detect from
+ * repo" (which reads the repo's dotenv examples) or the user, and the modal says so.
+ */
+function frontendConfigForImport(
+  directory: string,
+  backendBlockIds: readonly string[],
+): FrontendConfig {
+  const backendBindings: FrontendBackendBinding[] = backendBlockIds.map((serviceBlockId) => ({
+    envVar: '',
+    source: { kind: 'service', serviceBlockId },
+  }))
+  return { directory, backendBindings }
+}

package/app/utils/settlingLoop.spec.ts

@@ -0,0 +1,236 @@
+import { describe, it, expect } from 'vitest'
+import { createSettlingLoop, type FrameScheduler } from './settlingLoop'
+
+/** A hand-driven frame clock: `flush()` runs exactly one scheduled frame. */
+function fakeScheduler() {
+  let nextHandle = 1
+  const pending = new Map<number, () => void>()
+  const scheduler: FrameScheduler = {
+    schedule(run) {
+      const handle = nextHandle++
+      pending.set(handle, run)
+      return handle
+    },
+    cancel(handle) {
+      pending.delete(handle)
+    },
+  }
+  return {
+    scheduler,
+    pending: () => pending.size,
+    /** Run every currently scheduled frame; frames they schedule wait for the next flush. */
+    flush() {
+      const due = [...pending.entries()]
+      pending.clear()
+      for (const [, run] of due) run()
+    },
+  }
+}
+
+describe('createSettlingLoop', () => {
+  it('does not run until poked', () => {
+    const clock = fakeScheduler()
+    let frames = 0
+    const loop = createSettlingLoop({
+      compute: () => {
+        frames++
+        return false
+      },
+      scheduler: clock.scheduler,
+      settleFrames: 3,
+    })
+
+    expect(loop.awake()).toBe(false)
+    clock.flush()
+    expect(frames).toBe(0)
+  })
+
+  it('keeps running while the output changes, and parks once it holds still', () => {
+    const clock = fakeScheduler()
+    let changed = true
+    let frames = 0
+    const loop = createSettlingLoop({
+      compute: () => {
+        frames++
+        return changed
+      },
+      scheduler: clock.scheduler,
+      settleFrames: 3,
+    })
+
+    loop.poke()
+    for (let i = 0; i < 10; i++) clock.flush()
+    expect(frames).toBe(10)
+    expect(loop.awake()).toBe(true)
+
+    // The animation ends: three unchanged frames later the loop is parked and the frame
+    // count stops moving no matter how many times the clock ticks.
+    changed = false
+    clock.flush()
+    clock.flush()
+    expect(loop.awake()).toBe(true)
+    clock.flush()
+    expect(loop.awake()).toBe(false)
+
+    const settledAt = frames
+    for (let i = 0; i < 10; i++) clock.flush()
+    expect(frames).toBe(settledAt)
+  })
+
+  it('runs the settle tail after a poke that changed nothing, then parks', () => {
+    const clock = fakeScheduler()
+    let frames = 0
+    const loop = createSettlingLoop({
+      compute: () => {
+        frames++
+        return false
+      },
+      scheduler: clock.scheduler,
+      settleFrames: 3,
+    })
+
+    // A signal fires one frame BEFORE the transition it starts produces geometry, so a wake
+    // that measures no change still owes the tail rather than parking immediately.
+    loop.poke()
+    clock.flush()
+    expect(loop.awake()).toBe(true)
+    clock.flush()
+    clock.flush()
+    expect(frames).toBe(3)
+    expect(loop.awake()).toBe(false)
+  })
+
+  it('wakes a parked loop again on the next poke', () => {
+    const clock = fakeScheduler()
+    let frames = 0
+    const loop = createSettlingLoop({
+      compute: () => {
+        frames++
+        return false
+      },
+      scheduler: clock.scheduler,
+      settleFrames: 1,
+    })
+
+    loop.poke()
+    clock.flush()
+    expect(loop.awake()).toBe(false)
+
+    loop.poke()
+    clock.flush()
+    expect(frames).toBe(2)
+  })
+
+  it('restarts the countdown on a poke without scheduling a second frame', () => {
+    const clock = fakeScheduler()
+    let frames = 0
+    const loop = createSettlingLoop({
+      compute: () => {
+        frames++
+        return false
+      },
+      scheduler: clock.scheduler,
+      settleFrames: 2,
+    })
+
+    loop.poke()
+    loop.poke()
+    loop.poke()
+    expect(clock.pending()).toBe(1)
+    clock.flush()
+    expect(frames).toBe(1)
+  })
+
+  it('does not schedule a second frame when the compute itself pokes', () => {
+    const clock = fakeScheduler()
+    let frames = 0
+    // A compute that writes to a store can wake watchers that poke back synchronously. That
+    // must reset the countdown, not double the frame rate.
+    const loop = createSettlingLoop({
+      compute: () => {
+        frames++
+        loop.poke()
+        return false
+      },
+      scheduler: clock.scheduler,
+      settleFrames: 2,
+    })
+
+    loop.poke()
+    for (let i = 0; i < 5; i++) {
+      expect(clock.pending()).toBe(1)
+      clock.flush()
+    }
+    expect(frames).toBe(5)
+  })
+
+  it('parks a throwing compute so a later poke still wakes it', () => {
+    const clock = fakeScheduler()
+    let frames = 0
+    let broken = true
+    const loop = createSettlingLoop({
+      compute: () => {
+        frames++
+        if (broken) throw new Error('measured a card that just unmounted')
+        return false
+      },
+      scheduler: clock.scheduler,
+      settleFrames: 3,
+    })
+
+    // The frame the throw escaped from is already spent. Staying awake would leave the loop
+    // holding a stream it can never schedule on again, and every later poke a no-op.
+    loop.poke()
+    expect(() => clock.flush()).toThrow('measured a card that just unmounted')
+    expect(loop.awake()).toBe(false)
+    expect(clock.pending()).toBe(0)
+
+    broken = false
+    loop.poke()
+    clock.flush()
+    expect(frames).toBe(2)
+    expect(loop.awake()).toBe(true)
+  })
+
+  it('stays parked when the compute stops the loop', () => {
+    const clock = fakeScheduler()
+    let frames = 0
+    // A compute whose store write unmounts the board runs `stop()` from inside the frame it
+    // is halfway through. The frame it was about to schedule must not resurrect it.
+    const loop = createSettlingLoop({
+      compute: () => {
+        frames++
+        loop.stop()
+        return true
+      },
+      scheduler: clock.scheduler,
+      settleFrames: 3,
+    })
+
+    loop.poke()
+    clock.flush()
+    expect(loop.awake()).toBe(false)
+    expect(clock.pending()).toBe(0)
+    clock.flush()
+    expect(frames).toBe(1)
+  })
+
+  it('drops the pending frame on stop', () => {
+    const clock = fakeScheduler()
+    let frames = 0
+    const loop = createSettlingLoop({
+      compute: () => {
+        frames++
+        return true
+      },
+      scheduler: clock.scheduler,
+      settleFrames: 3,
+    })
+
+    loop.poke()
+    loop.stop()
+    expect(loop.awake()).toBe(false)
+    clock.flush()
+    expect(frames).toBe(0)
+  })
+})

package/app/utils/settlingLoop.ts

@@ -0,0 +1,101 @@
+/**
+ * A frame loop that stops itself once its output stops changing.
+ *
+ * The board's DOM-measuring drivers (dependency edges, task expansion) have to follow
+ * animations they cannot observe directly: a CSS height transition, a Vue Flow pan, a card
+ * reflowing after its text changed. Running them unconditionally every frame makes an idle
+ * board pay O(edges) forced layout reads 60 times a second; running them only on a change
+ * signal makes them stop mid-transition, because the signal fires when the transition
+ * STARTS and says nothing about the frames that follow.
+ *
+ * This resolves both: an external signal `poke()`s the loop awake, and the loop keeps
+ * running while `compute()` reports it changed something. Once the output has held still
+ * for `settleFrames` frames the animation is over and the loop parks at zero cost until the
+ * next poke.
+ *
+ * The scheduler is injected so the behaviour is testable without a browser frame clock.
+ */
+
+/** `requestAnimationFrame` / `cancelAnimationFrame`, injected so tests can drive frames by hand. */
+export type FrameScheduler = {
+  schedule: (run: () => void) => number
+  cancel: (handle: number) => void
+}
+
+export type SettlingLoop = {
+  /** Wake the loop, and reset the settle countdown if it is already awake. */
+  poke: () => void
+  /** Park the loop and drop the pending frame. Idempotent. */
+  stop: () => void
+  /**
+   * Whether the loop still owns the frame stream: a frame is scheduled, or `compute()` is
+   * running right now. The two are deliberately not the same fact, and only this one decides
+   * whether a `poke()` has to schedule anything.
+   */
+  awake: () => boolean
+}
+
+/**
+ * How many unchanged frames end a run. A signal fires when a style or class changes, one
+ * frame BEFORE the transition it starts produces any geometry, so parking on the first
+ * unchanged frame would miss every animation. Four frames (~66ms at 60Hz) clears that gap
+ * while keeping a false wake-up cheap.
+ */
+export const DEFAULT_SETTLE_FRAMES = 4
+
+export function createSettlingLoop(options: {
+  /** Runs one frame; returns whether it changed anything the user can see. */
+  compute: () => boolean
+  scheduler: FrameScheduler
+  settleFrames?: number
+}): SettlingLoop {
+  const { compute, scheduler } = options
+  const settleFrames = options.settleFrames ?? DEFAULT_SETTLE_FRAMES
+  /** The scheduled frame's handle, and ONLY that: null the whole time `compute()` runs. */
+  let pending: number | null = null
+  /** Whether the loop owns the frame stream, which stays true across `compute()`. */
+  let isAwake = false
+  let unchangedFrames = 0
+
+  function frame() {
+    // This callback's own handle is spent the moment it runs, so nothing may cancel it later;
+    // `isAwake` is what carries "the loop is running" across the compute below.
+    pending = null
+    let changed: boolean
+    try {
+      changed = compute()
+    } catch (error) {
+      // Park before letting the error reach the frame callback, where the browser reports it.
+      // Staying awake with no frame scheduled would make every later `poke()` a no-op, so one
+      // throwing frame would freeze the board for the rest of the session; rescheduling would
+      // be worse still, since a compute that threw on this frame throws on the next one too
+      // and a 60Hz error storm costs more than an arrow that waits for the next pulse.
+      isAwake = false
+      throw error
+    }
+    // A `stop()` that ran during `compute()` (an unmount driven by the compute's own store
+    // write) parks the loop for good: it must not be resurrected by the frame below.
+    if (!isAwake) return
+    unchangedFrames = changed ? 0 : unchangedFrames + 1
+    if (unchangedFrames < settleFrames) pending = scheduler.schedule(frame)
+    else isAwake = false
+  }
+
+  return {
+    poke() {
+      unchangedFrames = 0
+      // A poke triggered by the compute's own store write (a watcher, a re-render) resets the
+      // countdown and nothing more: `isAwake` is still set, so it cannot schedule a second
+      // frame beside the one `frame()` is about to schedule itself.
+      if (isAwake) return
+      isAwake = true
+      pending = scheduler.schedule(frame)
+    },
+    stop() {
+      isAwake = false
+      if (pending !== null) scheduler.cancel(pending)
+      pending = null
+    },
+    awake: () => isAwake,
+  }
+}

package/i18n/locales/de.json

@@ -1997,6 +1997,7 @@
           "oauthNotConnected": "war nicht verfügbar: dieses Board wurde noch nicht damit verbunden.",
           "oauthTokenFailed": "war nicht verfügbar: die Verbindung liefert kein Zugriffstoken mehr.",
           "overBudget": "war nicht verfügbar: dieser Agent deklariert mehr Tool-Server, als ein Lauf mitführt.",
+          "consensusPanel": "war nicht verfügbar: dieser Schritt lief als Konsens-Panel, und ein Panel hat keine Agentenlaufzeit, an die sich ein Tool-Server anschließen ließe.",
           "unknown": "war nicht verfügbar ({reason})."
         },
         "remedy": {
@@ -2007,7 +2008,8 @@
           "unusableSecret": "Korrigiere die Deklaration im Code der Installation: Die Zugangsdaten eines entfernten Servers reisen in einem Header, die eines lokalen werden in den Serverprozess injiziert.",
           "oauthNotConnected": "Verbinden Sie dieses Board im Infrastruktur-Fenster damit. Ein Deployment ohne ENCRYPTION_KEY hat keinen Ort für eine Berechtigung, das muss ein Betreiber also zuerst setzen.",
           "oauthTokenFailed": "Verbinden Sie es im Infrastruktur-Fenster neu, oder warten Sie die Störung des Anbieters ab.",
-          "overBudget": "Kürzen Sie, was der Agent deklariert, damit ein Lauf alles mitführen kann."
+          "overBudget": "Kürzen Sie, was der Agent deklariert, damit ein Lauf alles mitführen kann.",
+          "consensusPanel": "Schalten Sie Konsens für diesen Schritt ab, wenn er das Tool braucht, oder nehmen Sie in Kauf, dass das Panel ohne es urteilt. Am Server selbst muss sich nichts ändern."
         },
         "observed": {
           "ready": "gestartet",
@@ -3401,6 +3403,9 @@
       "monorepoBrowseHint": "Durchsuchen Sie das Repository und wählen Sie die Verzeichnisse der Services aus, die Sie hinzufügen möchten – aus jedem beliebigen Ordner. Agents, die an einem Service arbeiten, laufen innerhalb seines Unterverzeichnisses.",
       "selectedServices": "Ausgewählte Services",
       "noServicesSelected": "Noch keine Services ausgewählt. Wählen Sie oben Verzeichnisse aus.",
+      "frontendLabel": "Frontend-App (optional)",
+      "frontendHint": "Markieren Sie eines der ausgewählten Verzeichnisse als Frontend für die übrigen. Es wird als Frontend-App angelegt, auf dieses Unterverzeichnis festgelegt und mit jedem daneben hinzugefügten Backend-Service verknüpft. Die Umgebungsvariablen für die Backend-URLs benennen Sie anschließend im Inspector des Frontends.",
+      "frontendNone": "Keines: alle Auswahlen sind Backend-Services",
       "addServices": "{count} Service hinzufügen | {count} Services hinzufügen",
       "removeService": "{directory} entfernen",
       "addedConfigure": "{title} hinzugefügt, konfigurieren Sie es",
@@ -3414,7 +3419,9 @@
         "addedDescription": "{title} ist auf dem Board, konfigurieren Sie es unten.",
         "addFailedTitle": "Service konnte nicht hinzugefügt werden",
         "servicesAddedTitle": "Services hinzugefügt",
-        "servicesAddedDescription": "{count} Service zum Board hinzugefügt. | {count} Services zum Board hinzugefügt."
+        "servicesAddedDescription": "{count} Service zum Board hinzugefügt. | {count} Services zum Board hinzugefügt.",
+        "frontendLinkedNote": "{directory} wurde als Frontend hinzugefügt und mit den übrigen verknüpft. Benennen Sie die Umgebungsvariablen für die Backend-URLs im Inspector.",
+        "frontendWiringFailedNote": "Die Frontend-Einstellungen wurden nicht gespeichert. Öffnen Sie den Inspector jeder Frontend-App, um ihr Unterverzeichnis und ihre Backend-Services zu setzen."
       }
     },
     "repoTree": {
@@ -4363,6 +4370,9 @@
       "binaryCapabilityUnknown": "{capability} (eine Fähigkeit, die diese Installation nicht definiert)",
       "binaryCapabilityUnsupported": "Keine ausgewählte Integration unterstützt {capabilities}, was die Generierungsoptionen dieses Schritts verlangen. Entferne die Option oder wähle eine Integration, die die Fähigkeit deklariert.",
       "binaryCapabilityUnverifiable": "Keine ausgewählte Integration deklariert Unterstützung für {capabilities}, aber eine von ihnen deklariert überhaupt keine Fähigkeiten, daher konnte das nicht geprüft werden. Der Schritt startet trotzdem; prüfe es in der API der Integration.",
+      "binaryOptionValueUnaccepted": "Keine der ausgewählten Integrationen akzeptiert {option} von {requested}. Zusammen akzeptieren sie: {accepted}. Fordern Sie einen dieser Werte an oder wählen Sie eine Integration, die diesen Wert rendert.",
+      "binaryOptionValuePartial": "{generators} akzeptiert {option} von {requested} nicht, eine andere ausgewählte Integration jedoch schon. Der Schritt startet trotzdem: Senden Sie diese Option nur an die Integrationen, die sie akzeptieren, oder entfernen Sie die übrigen.",
+      "binaryOptionValueUnverifiable": "Eine ausgewählte Integration nennt die Werte, die sie akzeptiert, und akzeptiert nicht, was dieser Schritt verlangt ({options}); eine andere nennt gar keine, deshalb ließ sich das nicht klären. Der Schritt startet trotzdem, und nur ein Teil Ihrer Integrationen wird ihn bedienen.",
       "binaryReferenceImages": "Referenzbilder",
       "binaryReferenceImagesPlaceholder": "Rolle{'|'}Ort{'|'}Dienst, eine pro Zeile",
       "binaryReferenceImagesUnusable": "Nicht als Referenz gespeichert: {entries}. Jede Zeile muss Rolle{'|'}Ort sein, wobei die Rolle style, subject, composition oder base ist.",

package/i18n/locales/en.json

@@ -1541,6 +1541,7 @@
           "oauthNotConnected": "was not available: nobody has connected this board to it yet.",
           "oauthTokenFailed": "was not available: the connection stopped producing an access token.",
           "overBudget": "was not available: this agent declares more tool servers than one run carries.",
+          "consensusPanel": "was not available: this step ran as a consensus panel, and a panel has no agent runtime to connect a tool server to.",
           "unknown": "was not available ({reason})."
         },
         "remedy": {
@@ -1551,7 +1552,8 @@
           "unusableSecret": "Fix the declaration in the deployment's code: a remote server's credential rides a header, and a local one is injected into the server's own process.",
           "oauthNotConnected": "Connect this board to it from the Infrastructure window. A deployment with no ENCRYPTION_KEY has nowhere to keep a grant, so an operator has to set that first.",
           "oauthTokenFailed": "Reconnect it from the Infrastructure window, or wait out the vendor's outage.",
-          "overBudget": "Trim what the agent declares, so one run can carry all of it."
+          "overBudget": "Trim what the agent declares, so one run can carry all of it.",
+          "consensusPanel": "Turn consensus off for this step if it needs the tool, or accept that the panel judges without it. Nothing about the server has to change."
         },
         "observed": {
           "ready": "started",
@@ -4269,6 +4271,9 @@
       "monorepoBrowseHint": "Browse the repository and select the directories of the services you want to add — from any folder. Agents working on a service run within its subdirectory.",
       "selectedServices": "Selected services",
       "noServicesSelected": "No services selected yet. Pick directories above.",
+      "frontendLabel": "Frontend app (optional)",
+      "frontendHint": "Mark one of the selected directories as the frontend for the rest. It is added as a frontend app pinned to that subdirectory and linked to every backend service added beside it. Name each backend URL environment variable afterwards in the frontend's inspector.",
+      "frontendNone": "None: every selection is a backend service",
       "addServices": "Add {count} service | Add {count} services",
       "@addServices": {
         "description": "Count-driven button label; resolved via t(key, { count }, count) so {count} also drives the plural choice. Provide ALL plural forms your language needs (English has 2; Polish/Ukrainian need 3 - one/few/many - via the custom pluralRules in i18n.config.ts)."
@@ -4288,7 +4293,9 @@
         "servicesAddedDescription": "{count} service added to the board. | {count} services added to the board.",
         "@servicesAddedDescription": {
           "description": "Count-driven toast; resolved via t(key, { count }, count) so {count} also drives the plural choice. Provide ALL plural forms your language needs (Polish/Ukrainian need 3 - one/few/many)."
-        }
+        },
+        "frontendLinkedNote": "{directory} was added as the frontend and linked to the others. Name its backend URL environment variables in its inspector.",
+        "frontendWiringFailedNote": "The frontend settings did not save. Open each frontend app's inspector to set its subdirectory and its backend services."
       }
     },
     "repoTree": {
@@ -4953,6 +4960,9 @@
       "binaryCapabilityUnknown": "{capability} (a capability this deployment does not define)",
       "binaryCapabilityUnsupported": "No selected integration supports {capabilities}, which this step's generation options ask for. Remove the option, or select an integration that declares the capability.",
       "binaryCapabilityUnverifiable": "No selected integration declares support for {capabilities}, but one of them declares no capabilities at all, so this could not be checked. The step still starts; confirm it from the integration’s API.",
+      "binaryOptionValueUnaccepted": "No selected integration accepts {option} of {requested}. Between them they accept: {accepted}. Ask for one of those, or select an integration that renders this one.",
+      "binaryOptionValuePartial": "{generators} do not accept {option} of {requested}, but another selected integration does. The step still starts: send this option only to the integrations that accept it, or drop the ones that do not.",
+      "binaryOptionValueUnverifiable": "A selected integration states the values it accepts and does not accept what this step asks for ({options}), while another states none at all, so this could not be settled. The step still starts, and only some of your integrations will serve it.",
       "binaryReferenceImages": "Reference images",
       "binaryReferenceImagesPlaceholder": "role{'|'}location{'|'}service, one per line",
       "binaryReferenceImagesUnusable": "Not stored as references: {entries}. Each line must be role{'|'}location, where role is style, subject, composition or base.",

package/i18n/locales/es.json

@@ -1450,6 +1450,7 @@
           "oauthNotConnected": "no estuvo disponible: nadie ha conectado este tablero con él todavía.",
           "oauthTokenFailed": "no estuvo disponible: la conexión dejó de producir un token de acceso.",
           "overBudget": "no estuvo disponible: este agente declara más servidores de los que lleva una ejecución.",
+          "consensusPanel": "no estuvo disponible: este paso se ejecutó como un panel de consenso, y un panel no tiene entorno de agente al que conectar un servidor de herramientas.",
           "unknown": "no estuvo disponible ({reason})."
         },
         "remedy": {
@@ -1460,7 +1461,8 @@
           "unusableSecret": "Corrige la declaración en el código de la instalación: la credencial de un servidor remoto viaja en una cabecera y la de uno local se inyecta en el proceso del servidor.",
           "oauthNotConnected": "Conecta este tablero con él desde la ventana de Infraestructura. Un despliegue sin ENCRYPTION_KEY no tiene dónde guardar una concesión, así que un operador debe configurarla primero.",
           "oauthTokenFailed": "Vuelve a conectarlo desde la ventana de Infraestructura, o espera a que pase la caída del proveedor.",
-          "overBudget": "Recorta lo que declara el agente, para que una ejecución pueda llevarlo todo."
+          "overBudget": "Recorta lo que declara el agente, para que una ejecución pueda llevarlo todo.",
+          "consensusPanel": "Desactiva el consenso en este paso si necesita la herramienta, o acepta que el panel juzgue sin ella. No hay que cambiar nada del servidor."
         },
         "observed": {
           "ready": "iniciado",
@@ -4136,6 +4138,9 @@
       "monorepoBrowseHint": "Explora el repositorio y selecciona los directorios de los servicios que quieres añadir, de cualquier carpeta. Los agentes que trabajen en un servicio se ejecutarán dentro de su subdirectorio.",
       "selectedServices": "Servicios seleccionados",
       "noServicesSelected": "Aún no hay servicios seleccionados. Elige directorios arriba.",
+      "frontendLabel": "Aplicación frontend (opcional)",
+      "frontendHint": "Marca uno de los directorios seleccionados como el frontend de los demás. Se añade como aplicación frontend anclada a ese subdirectorio y se enlaza con cada servicio backend añadido junto a él. Después, asigna en el inspector del frontend el nombre de cada variable de entorno con la URL del backend.",
+      "frontendNone": "Ninguno: todas las selecciones son servicios backend",
       "addServices": "Añadir {count} servicio | Añadir {count} servicios",
       "removeService": "Quitar {directory}",
       "addedConfigure": "{title} añadido, configúralo",
@@ -4149,7 +4154,9 @@
         "addedDescription": "{title} está en el tablero, configúralo abajo.",
         "addFailedTitle": "No se pudo añadir el servicio",
         "servicesAddedTitle": "Servicios añadidos",
-        "servicesAddedDescription": "{count} servicio añadido al tablero. | {count} servicios añadidos al tablero."
+        "servicesAddedDescription": "{count} servicio añadido al tablero. | {count} servicios añadidos al tablero.",
+        "frontendLinkedNote": "{directory} se añadió como frontend y se enlazó con los demás. Asigna el nombre de sus variables de entorno con las URL de backend en su inspector.",
+        "frontendWiringFailedNote": "Los ajustes del frontend no se guardaron. Abre el inspector de cada aplicación frontend para definir su subdirectorio y sus servicios backend."
       },
       "repoType": "Tipo de repositorio",
       "repoTypeHint": "Qué es este repositorio: un servicio backend, una aplicación frontend, una biblioteca compartida o un repositorio de documentación (solo documentos/spikes)."
@@ -4802,6 +4809,9 @@
       "binaryCapabilityUnknown": "{capability} (una capacidad que esta instalación no define)",
       "binaryCapabilityUnsupported": "Ninguna integración seleccionada admite {capabilities}, que las opciones de generación de este paso solicitan. Quita la opción o selecciona una integración que declare la capacidad.",
       "binaryCapabilityUnverifiable": "Ninguna integración seleccionada declara admitir {capabilities}, pero una de ellas no declara capacidad alguna, así que no se pudo comprobar. El paso arranca igualmente; confírmalo en la API de la integración.",
+      "binaryOptionValueUnaccepted": "Ninguna integración seleccionada acepta {option} de {requested}. Entre todas aceptan: {accepted}. Pide uno de esos valores o selecciona una integración que genere este.",
+      "binaryOptionValuePartial": "{generators} no acepta {option} de {requested}, pero otra integración seleccionada sí. El paso se inicia igualmente: envía esta opción solo a las integraciones que la aceptan, o quita las que no.",
+      "binaryOptionValueUnverifiable": "Una integración seleccionada indica los valores que acepta y no acepta lo que pide este paso ({options}), mientras que otra no indica ninguno, así que no se pudo comprobar. El paso se inicia igualmente y solo algunas de tus integraciones lo atenderán.",
       "binaryReferenceImages": "Imágenes de referencia",
       "binaryReferenceImagesPlaceholder": "rol{'|'}ubicación{'|'}servicio, una por línea",
       "binaryReferenceImagesUnusable": "No se guardaron como referencia: {entries}. Cada línea debe ser rol{'|'}ubicación, con el rol style, subject, composition o base.",