@cat-factory/app 0.167.0 → 0.168.0

package/app/stores/tasks.ts

@@ -146,14 +146,17 @@ export const useTasksStore = defineStore('tasks', () => {
 
   /**
    * Search a connected tracker's issues by free text (title/content). `blockId`
-   * (a service frame or a task/module under one) scopes a GitHub search to that
-   * service's linked repo — so hits stay in-repo and a pasted URL / bare issue
-   * number resolves to the exact issue. Omitted → an unscoped workspace search.
+   * (a service frame or a task/module under one) is REQUIRED: it scopes a GitHub
+   * search to that service's linked repo, so hits stay in-repo and a bare issue
+   * number resolves to the exact issue. There is no unscoped mode — an unscoped
+   * GitHub search reaches every repository the backend's credential can see. An
+   * issue in another repo is linked by pasting its URL (the picker's by-reference
+   * row imports it directly instead of searching).
    */
   async function search(
     source: TaskSourceKind,
     query: string,
-    blockId?: string,
+    blockId: string,
   ): Promise<TaskSearchResult[]> {
     const { results } = await api.searchTaskSource(workspace.requireId(), source, query, blockId)
     return results

package/app/stores/uiMode.spec.ts

@@ -0,0 +1,151 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+import { createPinia, setActivePinia } from 'pinia'
+import { nextTick } from 'vue'
+import { useUiModeStore } from '~/stores/uiMode'
+import type { UiMode } from '~/utils/uiMode'
+
+/**
+ * Point `runtimeConfig.public.uiMode` at a value and hand back a store built against it.
+ * The env value is read ONCE at store setup (it is build-time-baked in a `ssr: false` SPA),
+ * so every case needs a fresh Pinia — which is also what proves the read isn't reactive.
+ */
+function storeWithEnv(uiMode: string | undefined) {
+  vi.stubGlobal('useRuntimeConfig', () => ({ public: { apiBase: '', uiMode } }))
+  setActivePinia(createPinia())
+  return useUiModeStore()
+}
+
+describe('useUiModeStore mode resolution', () => {
+  beforeEach(() => {
+    // The default runtime-config stub carries no `uiMode` at all — the shape a deployment
+    // that never set NUXT_PUBLIC_UI_MODE ends up with once Nuxt applies the '' default.
+    vi.stubGlobal('useRuntimeConfig', () => ({ public: { apiBase: '', uiMode: '' } }))
+  })
+
+  it('boots in basic mode with no env pin and nothing stored', () => {
+    const ui = useUiModeStore()
+    expect(ui.mode).toBe('basic')
+    expect(ui.isAdvanced).toBe(false)
+    expect(ui.envPinned).toBe(false)
+  })
+
+  it('honours the browser-stored choice when no env pin is present', () => {
+    const ui = useUiModeStore()
+    ui.setMode('advanced')
+    expect(ui.mode).toBe('advanced')
+    expect(ui.isAdvanced).toBe(true)
+    // Persisted, so a reload restores it (the persist plugin picks `storedMode`).
+    expect(ui.storedMode).toBe('advanced')
+  })
+
+  it('lets the env pin override a conflicting stored choice, in both directions', () => {
+    const pinnedBasic = storeWithEnv('advanced')
+    pinnedBasic.storedMode = 'basic'
+    expect(pinnedBasic.mode).toBe('advanced')
+
+    const pinnedAdvanced = storeWithEnv('basic')
+    pinnedAdvanced.storedMode = 'advanced'
+    expect(pinnedAdvanced.mode).toBe('basic')
+  })
+
+  it('refuses to record a preference under an env pin', () => {
+    const ui = storeWithEnv('basic')
+    expect(ui.envPinned).toBe(true)
+    ui.setMode('advanced')
+    ui.toggleMode()
+    // Nothing written: the resolver would ignore it, so persisting it would be a lie.
+    expect(ui.storedMode).toBeNull()
+    expect(ui.mode).toBe('basic')
+  })
+
+  it('ignores an unrecognised env value rather than failing the boot', () => {
+    const ui = storeWithEnv('expert')
+    expect(ui.envPinned).toBe(false)
+    expect(ui.mode).toBe('basic')
+    ui.setMode('advanced')
+    expect(ui.mode).toBe('advanced')
+  })
+
+  it('toggleMode flips between the two tiers', () => {
+    const ui = useUiModeStore()
+    ui.toggleMode()
+    expect(ui.mode).toBe('advanced')
+    ui.toggleMode()
+    expect(ui.mode).toBe('basic')
+  })
+})
+
+describe('useUiModeStore navbar collapse', () => {
+  beforeEach(() => {
+    vi.stubGlobal('useRuntimeConfig', () => ({ public: { apiBase: '', uiMode: '' } }))
+  })
+
+  it('starts collapsed in basic mode and expanded in advanced mode', () => {
+    expect(useUiModeStore().navCollapsed).toBe(true)
+
+    const advanced = storeWithEnv('advanced')
+    expect(advanced.navCollapsed).toBe(false)
+  })
+
+  it('remembers the rail choice in EITHER tier, across a reload', () => {
+    // The persisted shape is per-tier, so an expand in basic is remembered just as an advanced
+    // one is — the default is what differs between the tiers, not whether a choice sticks.
+    const ui = useUiModeStore()
+    ui.toggleNav()
+    expect(ui.navCollapsed).toBe(false)
+    expect(ui.railCollapsed.basic).toBe(false)
+
+    const advanced = storeWithEnv('advanced')
+    advanced.toggleNav()
+    expect(advanced.navCollapsed).toBe(true)
+    expect(advanced.railCollapsed.advanced).toBe(true)
+  })
+
+  it('keeps each tier’s rail state independent across a switch', async () => {
+    const ui = useUiModeStore()
+    // Expand in basic, then collapse in advanced: neither choice may leak into the other tier.
+    ui.toggleNav()
+    expect(ui.navCollapsed).toBe(false)
+
+    ui.setMode('advanced')
+    await nextTick()
+    expect(ui.navCollapsed).toBe(false) // advanced's own default
+    ui.toggleNav()
+    expect(ui.navCollapsed).toBe(true)
+
+    ui.setMode('basic')
+    await nextTick()
+    expect(ui.navCollapsed).toBe(false) // the basic expand survived the round trip
+
+    ui.setMode('advanced')
+    await nextTick()
+    expect(ui.navCollapsed).toBe(true)
+  })
+
+  it('falls back to the tier default when the restored preference is missing a key', () => {
+    // A persisted blob from an older build (or a hand-edited cookie) can omit a tier; a rail
+    // stuck on `undefined` would render expanded, which is wrong for basic.
+    const ui = useUiModeStore()
+    ui.railCollapsed = {} as Record<UiMode, boolean>
+    expect(ui.navCollapsed).toBe(true)
+    ui.setMode('advanced')
+    expect(ui.navCollapsed).toBe(false)
+  })
+
+  it('setNavCollapsed is idempotent', () => {
+    const ui = storeWithEnv('advanced')
+    ui.setNavCollapsed(true)
+    ui.setNavCollapsed(true)
+    expect(ui.navCollapsed).toBe(true)
+    ui.setNavCollapsed(false)
+    expect(ui.navCollapsed).toBe(false)
+  })
+})
+
+describe('useUiModeStore typing', () => {
+  it('exposes the mode as the closed union', () => {
+    const ui = useUiModeStore()
+    const mode: UiMode = ui.mode
+    expect(['basic', 'advanced']).toContain(mode)
+  })
+})

package/app/stores/uiMode.ts

@@ -0,0 +1,88 @@
+import { defineStore } from 'pinia'
+import { computed, ref } from 'vue'
+import { DEFAULT_RAIL_COLLAPSED, parseUiMode, resolveUiMode, type UiMode } from '~/utils/uiMode'
+
+/**
+ * The interface tier (`basic` / `advanced`) and the side-navbar collapse state.
+ *
+ * Mode resolution is `env → browser-stored → basic` (see `utils/uiMode.ts`). The env value
+ * is `runtimeConfig.public.uiMode`, i.e. `NUXT_PUBLIC_UI_MODE`: the SPA is `ssr: false`, so
+ * — exactly like `apiBase` — it is baked in at build time and cannot change while the app
+ * is loaded. It is therefore read ONCE here rather than tracked reactively. Only the user's
+ * own choice is persisted, so a deployment that later drops its env pin falls back to
+ * whatever the user last picked instead of to the default.
+ *
+ * The collapse state is a PER-TIER preference (`railCollapsed`), not a single boolean. The two
+ * tiers want different resting states — basic opens railed, advanced expanded — so one shared
+ * flag can only serve one of them: it would either override the other tier's default or throw
+ * away the user's choice on every switch. Keying the preference by tier gives each its own
+ * default (`DEFAULT_RAIL_COLLAPSED`) AND its own memory, so switching tiers restores what that
+ * tier last looked like and neither has to forget. That is also why there is no watcher here:
+ * the collapse follows `mode` because it is indexed by it, not because something resets on
+ * change.
+ */
+export const useUiModeStore = defineStore(
+  'uiMode',
+  () => {
+    const envMode = parseUiMode(useRuntimeConfig().public.uiMode)
+
+    /** The user's explicit pick, persisted. `null` until they choose one. */
+    const storedMode = ref<UiMode | null>(null)
+    /** The rail state each tier was last left in, persisted. Seeded from the per-tier defaults. */
+    const railCollapsed = ref<Record<UiMode, boolean>>({ ...DEFAULT_RAIL_COLLAPSED })
+
+    const mode = computed<UiMode>(() => resolveUiMode(envMode, storedMode.value))
+    const isAdvanced = computed(() => mode.value === 'advanced')
+    /** Pinned by the deployment: the switcher is read-only, since a write would be ignored. */
+    const envPinned = computed(() => envMode !== null)
+
+    // `?? the default` because the restored value is untrusted input, exactly like the env
+    // string: a persisted blob written by an older build (or hand-edited) can be missing this
+    // tier's key, and a rail stuck on `undefined` would render as expanded in basic mode.
+    const navCollapsed = computed(
+      () => railCollapsed.value[mode.value] ?? DEFAULT_RAIL_COLLAPSED[mode.value],
+    )
+
+    /**
+     * Record the user's pick. A no-op under an env pin — the resolver would ignore it.
+     *
+     * This guard is hygiene, not the invariant. `storedMode` is returned from the store because
+     * a setup store can only persist what it returns (as in `auth`, `accounts`, `workspace`), so
+     * a caller CAN write it directly and skip this check. That is harmless by construction:
+     * `mode` runs `resolveUiMode(env, stored)`, which consults the env pin FIRST, so a direct
+     * write can leave a stale persisted value but can never change the tier under a pin. The
+     * "env pin wins, in both directions" case above is what actually pins that.
+     */
+    function setMode(next: UiMode) {
+      if (envPinned.value) return
+      storedMode.value = next
+    }
+
+    function toggleMode() {
+      setMode(isAdvanced.value ? 'basic' : 'advanced')
+    }
+
+    /** Remember the rail state for the CURRENT tier; the other tier keeps its own. */
+    function setNavCollapsed(collapsed: boolean) {
+      railCollapsed.value = { ...railCollapsed.value, [mode.value]: collapsed }
+    }
+
+    function toggleNav() {
+      setNavCollapsed(!navCollapsed.value)
+    }
+
+    return {
+      mode,
+      isAdvanced,
+      envPinned,
+      storedMode,
+      railCollapsed,
+      navCollapsed,
+      setMode,
+      toggleMode,
+      setNavCollapsed,
+      toggleNav,
+    }
+  },
+  { persist: { pick: ['storedMode', 'railCollapsed'] } },
+)

package/app/utils/connectionWarnings.ts

@@ -0,0 +1,17 @@
+import type { ConnectionWarningCode } from '@cat-factory/contracts'
+
+// A connection test can report non-fatal GAPS in the config beside its pass/fail verdict: the
+// backend states them as machine-readable codes (it does not localize prose), and the copy the
+// operator reads lives here.
+//
+// The exhaustive `Record<ConnectionWarningCode, …>` is the tier-2 drift guard: a backend that
+// adds a warning code fails this typecheck until the SPA has copy for it, which the typed-key
+// check alone cannot catch for a runtime-assembled key.
+
+/** Config-gap warning code → i18n key. Leaf keys mirror the code verbatim. */
+export const CONNECTION_WARNING_KEYS: Record<ConnectionWarningCode, string> = {
+  runner_manifest_no_release:
+    'settings.providerConnection.test.warnings.runner_manifest_no_release',
+  runner_manifest_no_status_path:
+    'settings.providerConnection.test.warnings.runner_manifest_no_status_path',
+}

package/app/utils/uiMode.spec.ts

@@ -0,0 +1,67 @@
+import { describe, expect, it } from 'vitest'
+import { DEFAULT_UI_MODE, parseUiMode, resolveUiMode, showOverrideField, UI_MODES } from './uiMode'
+
+describe('parseUiMode', () => {
+  it('accepts every known mode, case- and whitespace-insensitively', () => {
+    for (const mode of UI_MODES) {
+      expect(parseUiMode(mode)).toBe(mode)
+      expect(parseUiMode(` ${mode.toUpperCase()} `)).toBe(mode)
+    }
+  })
+
+  it('reports no opinion for an unset / unrecognised / non-string value', () => {
+    // '' is what `runtimeConfig.public.uiMode` carries when NUXT_PUBLIC_UI_MODE is unset, so
+    // it MUST read as "no env pin" rather than as an invalid mode.
+    for (const raw of ['', '   ', 'expert', 'Basic mode', undefined, null, 1, {}]) {
+      expect(parseUiMode(raw)).toBeNull()
+    }
+  })
+})
+
+describe('resolveUiMode', () => {
+  it('lets the env pin win over the stored choice', () => {
+    expect(resolveUiMode('basic', 'advanced')).toBe('basic')
+    expect(resolveUiMode('advanced', 'basic')).toBe('advanced')
+  })
+
+  it('falls back to the stored choice, then to the default', () => {
+    expect(resolveUiMode(null, 'advanced')).toBe('advanced')
+    expect(resolveUiMode(null, null)).toBe(DEFAULT_UI_MODE)
+    expect(DEFAULT_UI_MODE).toBe('basic')
+  })
+})
+
+describe('showOverrideField', () => {
+  it('shows every override control in advanced mode, set or not', () => {
+    expect(showOverrideField(true)).toBe(true)
+    expect(showOverrideField(true, null)).toBe(true)
+    expect(showOverrideField(true, 'preset_1')).toBe(true)
+  })
+
+  it('hides an unset override in basic mode', () => {
+    // The three shapes an unset override arrives in: absent, explicitly null, or the empty
+    // string a cleared picker writes. All mean "inherit the default", so nothing is concealed.
+    for (const unset of [undefined, null, '']) expect(showOverrideField(false, unset)).toBe(false)
+    expect(showOverrideField(false)).toBe(false)
+  })
+
+  it('reveals a SET override in basic mode so it stays visible and clearable', () => {
+    // The regression this guards: a block that already carries an override would otherwise run
+    // on settings a basic-mode user can neither see nor clear.
+    expect(showOverrideField(false, 'policy_strict')).toBe(true)
+    expect(showOverrideField(false, true)).toBe(true)
+  })
+
+  it('treats `false` as a real override, not as absence', () => {
+    // `technical: false` means "business task" — an explicit choice that must NOT be read as
+    // unset, which a plain truthiness check would get wrong.
+    expect(showOverrideField(false, false)).toBe(true)
+  })
+
+  it('reveals a multi-value group when any one of its values is set', () => {
+    // The tracker-writeback group edits three tri-states behind one heading.
+    expect(showOverrideField(false, null, null, null)).toBe(false)
+    expect(showOverrideField(false, null, false, null)).toBe(true)
+    expect(showOverrideField(false, null, null, true)).toBe(true)
+  })
+})

package/app/utils/uiMode.ts

@@ -0,0 +1,71 @@
+/**
+ * The interface tier the SPA renders at: `basic` shows the everyday surface, `advanced`
+ * shows every destination and every run/pipeline option. Pure resolution logic, kept out
+ * of the store so it is testable without Pinia or a Nuxt runtime.
+ *
+ * Precedence is fixed and NOT negotiable per surface: the deployment's env value always
+ * wins over the browser-stored user choice, which wins over the `basic` default. That
+ * ordering is what lets an operator pin a fleet of kiosk-ish deployments to one tier
+ * without a per-browser reset, so `setMode` is a no-op while the env pin is present
+ * rather than writing a preference the resolver would then ignore.
+ */
+export const UI_MODES = ['basic', 'advanced'] as const
+
+export type UiMode = (typeof UI_MODES)[number]
+
+/** The tier a deployment gets when neither env nor the browser says otherwise. */
+export const DEFAULT_UI_MODE: UiMode = 'basic'
+
+/**
+ * The side-navbar rail state each tier STARTS in, before the user touches the toggle. Basic
+ * opens railed (the icon rail is part of what makes it feel basic) and advanced opens
+ * expanded. A default, not a rule: the preference is per-tier and remembered, so an explicit
+ * choice in either tier survives both a reload and a round trip through the other tier.
+ */
+export const DEFAULT_RAIL_COLLAPSED: Record<UiMode, boolean> = { basic: true, advanced: false }
+
+/**
+ * Coerce an untrusted value (a `NUXT_PUBLIC_UI_MODE` string baked into the bundle, or a
+ * restored cookie/localStorage value) to a known mode. Anything unrecognised — including
+ * the empty string the runtime-config default carries when the env var is unset — resolves
+ * to `null`, i.e. "this layer has no opinion", so the next one down decides. Never throws:
+ * a typo'd env value must degrade to the default rather than fail the boot.
+ */
+export function parseUiMode(raw: unknown): UiMode | null {
+  if (typeof raw !== 'string') return null
+  const value = raw.trim().toLowerCase()
+  return (UI_MODES as readonly string[]).includes(value) ? (value as UiMode) : null
+}
+
+/** Apply the precedence: env pin → browser-stored user choice → {@link DEFAULT_UI_MODE}. */
+export function resolveUiMode(env: UiMode | null, stored: UiMode | null): UiMode {
+  return env ?? stored ?? DEFAULT_UI_MODE
+}
+
+/**
+ * An override value is SET when it deviates from the inherited default. `null`/`undefined`
+ * (and the empty string a cleared picker writes) mean "inherit"; every other value — INCLUDING
+ * `false`, which is a real choice on a tri-state like `technical` — is an explicit override.
+ */
+function isOverrideSet(value: unknown): boolean {
+  return value != null && value !== ''
+}
+
+/**
+ * Whether an OVERRIDE control is rendered at the current tier.
+ *
+ * Basic mode hides the controls whose only job is to override something already decided
+ * elsewhere (a workspace-level default, an engine-inferred flag), which is safe ONLY while
+ * what remains is exactly the value the hidden control would have shown. The moment a block
+ * actually carries an override that stops being true: hiding it would leave a basic-mode user
+ * looking at a task that runs on settings they cannot see, let alone clear — and nothing else
+ * in the inspector surfaces them. So basic mode hides the control only while EVERY value it
+ * edits is unset, and reveals it (exactly as advanced mode renders it, editable, so the
+ * override can be cleared) as soon as one is not.
+ *
+ * Variadic because a single control can own several values — the tracker-writeback group edits
+ * three tri-states behind one heading, and any one of them being set must reveal the group.
+ */
+export function showOverrideField(isAdvanced: boolean, ...values: readonly unknown[]): boolean {
+  return isAdvanced || values.some(isOverrideSet)
+}

package/i18n/locales/de.json

@@ -298,7 +298,12 @@
       "test": {
         "button": "Verbindung testen",
         "ok": "Verbindung OK",
-        "failed": "Verbindung fehlgeschlagen"
+        "failed": "Verbindung fehlgeschlagen",
+        "warningsTitle": "Lücken in dieser Konfiguration",
+        "warnings": {
+          "runner_manifest_no_release": "Kein Release-Template: Beim Abbrechen eines Laufs kann dem Pool nicht mitgeteilt werden, dass er seinen Job stoppen soll. Ein verwaister Job belegt seinen Runner, bis der Pool ihn von selbst zurücknimmt.",
+          "runner_manifest_no_status_path": "Kein Statuspfad: Jede Abfrage wird als weiterhin laufend gelesen. Ein Job kann daher nur enden, wenn das Abfragebudget des Laufs aufgebraucht ist."
+        }
       },
       "toast": {
         "saved": "{title} gespeichert",
@@ -1992,7 +1997,8 @@
         "localModels": "Meine lokalen Runner",
         "sandbox": "Sandbox öffnen",
         "shortcuts": "Tastenkürzel",
-        "bugHunt": "Fehlerjagd"
+        "bugHunt": "Fehlerjagd",
+        "toggleUiMode": "Oberflächenmodus wechseln"
       },
       "keywords": {
         "newPipeline": "pipeline agents chain",
@@ -2013,7 +2019,8 @@
         "localModels": "local model runner ollama lm studio llamacpp vllm endpoint",
         "sandbox": "sandbox prompt model test experiment judge fixture benchmark evaluate",
         "shortcuts": "keyboard shortcuts keys hotkeys cheatsheet help",
-        "bugHunt": "fehler bug jagd triage backlog tracker nicht zugewiesen"
+        "bugHunt": "fehler bug jagd triage backlog tracker nicht zugewiesen",
+        "toggleUiMode": "oberfläche modus einfach erweitert anzeigen ausblenden"
       }
     },
     "shortcuts": {
@@ -3242,10 +3249,11 @@
       "searchPlaceholder": "Issues durchsuchen oder eine URL/einen Schlüssel einfügen…",
       "refPlaceholder": "Eine Issue-URL oder einen -Schlüssel einfügen…",
       "searchFailed": "Suche fehlgeschlagen: {error}",
+      "searchNeedsRepo": "Dieser Service ist noch mit keinem Repository verknüpft, es gibt also nichts zu durchsuchen. Verknüpfen Sie ihn mit einem Repository oder fügen Sie eine Issue-URL ein, um ein Issue direkt anzuhängen.",
       "imported": "importiert",
       "attachByReference": "{ref} per Referenz anhängen",
-      "noMatches": "Keine passenden Issues.",
-      "emptySearchable": "Nach Titel suchen oder ein importiertes Issue auswählen.",
+      "noMatches": "Keine passenden Issues im Repository dieses Service. Fügen Sie eine Issue-URL ein, um eines von anderswo anzuhängen.",
+      "emptySearchable": "Durchsuchen Sie das Repository dieses Service nach Titel oder wählen Sie ein importiertes Issue aus.",
       "emptyRefOnly": "Fügen Sie eine Issue-URL oder einen -Schlüssel ein, um es anzuhängen.",
       "sourceLabel": "Quelle",
       "noSource": "Quelle wählen",
@@ -4202,6 +4210,14 @@
       "dismiss": "Schließen"
     }
   },
+  "uiMode": {
+    "switcher": "Oberfläche",
+    "basic": "Einfach",
+    "advanced": "Erweitert",
+    "basicHint": "Nur die alltäglichen Werkzeuge. Für alles auf „Erweitert“ umschalten.",
+    "advancedHint": "Alle Bereiche und alle Ausführungsoptionen.",
+    "pinned": "Von dieser Installation festgelegt"
+  },
   "common": {
     "loading": "Wird geladen…",
     "save": "Speichern",
@@ -4274,6 +4290,8 @@
     "menu": "Navigationsmenü",
     "openMenu": "Menü öffnen",
     "closeMenu": "Menü schließen",
+    "expandSidebar": "Seitenleiste ausklappen",
+    "collapseSidebar": "Seitenleiste einklappen",
     "commandBar": "Suchen oder einen Befehl ausführen…",
     "create": "Erstellen",
     "buildPipeline": "Eine Pipeline erstellen",

package/i18n/locales/en.json

@@ -23,6 +23,17 @@
       "dismiss": "Dismiss"
     }
   },
+  "uiMode": {
+    "switcher": "Interface",
+    "@switcher": {
+      "description": "Label above the picker that chooses how much of the app is shown (Basic or Advanced). It names the app's user interface, NOT a programming interface."
+    },
+    "basic": "Basic",
+    "advanced": "Advanced",
+    "basicHint": "Everyday tools only. Switch to Advanced to see everything.",
+    "advancedHint": "Every destination and every run option.",
+    "pinned": "Set by this deployment"
+  },
   "common": {
     "loading": "Loading…",
     "save": "Save",
@@ -107,6 +118,8 @@
     "menu": "Navigation menu",
     "openMenu": "Open menu",
     "closeMenu": "Close menu",
+    "expandSidebar": "Expand sidebar",
+    "collapseSidebar": "Collapse sidebar",
     "commandBar": "Search or run a command…",
     "create": "Create",
     "buildPipeline": "Build a pipeline",
@@ -2006,7 +2019,8 @@
         "localModels": "My local runners",
         "sandbox": "Open Sandbox",
         "shortcuts": "Keyboard shortcuts",
-        "bugHunt": "Bug hunt"
+        "bugHunt": "Bug hunt",
+        "toggleUiMode": "Switch interface mode"
       },
       "keywords": {
         "newPipeline": "pipeline agents chain",
@@ -2027,7 +2041,8 @@
         "localModels": "local model runner ollama lm studio llamacpp vllm endpoint",
         "sandbox": "sandbox prompt model test experiment judge fixture benchmark evaluate",
         "shortcuts": "keyboard shortcuts keys hotkeys cheatsheet help",
-        "bugHunt": "bug hunt triage backlog issue tracker unassigned"
+        "bugHunt": "bug hunt triage backlog issue tracker unassigned",
+        "toggleUiMode": "interface mode basic advanced simple expert show hide"
       }
     },
     "shortcuts": {
@@ -2467,7 +2482,12 @@
       "test": {
         "button": "Test connection",
         "ok": "Connection OK",
-        "failed": "Connection failed"
+        "failed": "Connection failed",
+        "warningsTitle": "Gaps in this configuration",
+        "warnings": {
+          "runner_manifest_no_release": "No release template: cancelling a run cannot tell the pool to stop its job, so an orphaned job keeps its runner until the pool reclaims it on its own.",
+          "runner_manifest_no_status_path": "No status path: every poll reads as still running, so a job can only end by exhausting the run's poll budget."
+        }
       },
       "toast": {
         "saved": "{title} saved",
@@ -3641,10 +3661,11 @@
       "searchPlaceholder": "Search issues or paste a URL/key…",
       "refPlaceholder": "Paste an issue URL or key…",
       "searchFailed": "Search failed: {error}",
+      "searchNeedsRepo": "This service isn't linked to a repository yet, so there's nothing to search. Link it to a repo, or paste an issue URL to attach one directly.",
       "imported": "imported",
       "attachByReference": "Attach {ref} by reference",
-      "noMatches": "No matching issues.",
-      "emptySearchable": "Search by title, or pick an imported issue.",
+      "noMatches": "No matching issues in this service's repository. Paste an issue URL to attach one from elsewhere.",
+      "emptySearchable": "Search this service's repository by title, or pick an imported issue.",
       "emptyRefOnly": "Paste an issue URL or key to attach it.",
       "sourceLabel": "Source",
       "noSource": "Choose a source",

package/i18n/locales/es.json

@@ -23,6 +23,14 @@
       "dismiss": "Descartar"
     }
   },
+  "uiMode": {
+    "switcher": "Interfaz",
+    "basic": "Básica",
+    "advanced": "Avanzada",
+    "basicHint": "Solo las herramientas del día a día. Cambia a Avanzada para verlo todo.",
+    "advancedHint": "Todas las secciones y todas las opciones de ejecución.",
+    "pinned": "Definido por este despliegue"
+  },
   "common": {
     "loading": "Cargando…",
     "save": "Guardar",
@@ -95,6 +103,8 @@
     "menu": "Menú de navegación",
     "openMenu": "Abrir menú",
     "closeMenu": "Cerrar menú",
+    "expandSidebar": "Expandir barra lateral",
+    "collapseSidebar": "Contraer barra lateral",
     "commandBar": "Buscar o ejecutar un comando…",
     "create": "Crear",
     "buildPipeline": "Crear una canalización",
@@ -1940,7 +1950,8 @@
         "localModels": "Mis ejecutores locales",
         "sandbox": "Abrir el entorno de pruebas",
         "shortcuts": "Atajos de teclado",
-        "bugHunt": "Caza de errores"
+        "bugHunt": "Caza de errores",
+        "toggleUiMode": "Cambiar el modo de interfaz"
       },
       "keywords": {
         "newPipeline": "canalización agentes cadena pipeline",
@@ -1961,7 +1972,8 @@
         "localModels": "modelo local ejecutor ollama lm studio llamacpp vllm endpoint",
         "sandbox": "entorno de pruebas prompt modelo prueba experimento juez fixture benchmark evaluar",
         "shortcuts": "atajos teclado teclas ayuda",
-        "bugHunt": "error bug caza triaje backlog incidencias sin asignar"
+        "bugHunt": "error bug caza triaje backlog incidencias sin asignar",
+        "toggleUiMode": "interfaz modo básico avanzado mostrar ocultar"
       }
     },
     "integrationsHub": {
@@ -2202,7 +2214,12 @@
       "test": {
         "button": "Probar conexión",
         "ok": "Conexión correcta",
-        "failed": "Falló la conexión"
+        "failed": "Falló la conexión",
+        "warningsTitle": "Carencias en esta configuración",
+        "warnings": {
+          "runner_manifest_no_release": "Sin plantilla de release: al cancelar una ejecución no se puede indicar al pool que detenga su trabajo, así que un trabajo huérfano ocupa su runner hasta que el pool lo recupere por su cuenta.",
+          "runner_manifest_no_status_path": "Sin ruta de estado: cada sondeo se interpreta como todavía en ejecución, así que un trabajo solo puede terminar agotando el presupuesto de sondeo de la ejecución."
+        }
       },
       "toast": {
         "saved": "{title} guardado",
@@ -3536,10 +3553,11 @@
       "searchPlaceholder": "Busca incidencias o pega una URL/clave…",
       "refPlaceholder": "Pega la URL o clave de una incidencia…",
       "searchFailed": "La búsqueda falló: {error}",
+      "searchNeedsRepo": "Este servicio aún no está vinculado a un repositorio, así que no hay nada donde buscar. Vincúlalo a un repositorio o pega la URL de una incidencia para adjuntarla directamente.",
       "imported": "importada",
       "attachByReference": "Adjuntar {ref} por referencia",
-      "noMatches": "No hay incidencias coincidentes.",
-      "emptySearchable": "Busca por título o elige una incidencia importada.",
+      "noMatches": "No hay incidencias coincidentes en el repositorio de este servicio. Pega la URL de una incidencia para adjuntar una de otro sitio.",
+      "emptySearchable": "Busca por título en el repositorio de este servicio o elige una incidencia importada.",
       "emptyRefOnly": "Pega la URL o clave de una incidencia para adjuntarla.",
       "sourceLabel": "Fuente",
       "noSource": "Elige una fuente",