@cat-factory/app 0.115.2 → 0.116.0

package/app/stores/environmentTest.spec.ts

@@ -0,0 +1,103 @@
+import { describe, it, expect, beforeEach, vi } from 'vitest'
+import type { EnvironmentTestRun } from '~/types/domain'
+import { useEnvironmentTestStore } from '~/stores/environmentTest'
+
+// The store resolves `useApi()` at setup; override the inert global stub from
+// `test/setup.ts` with a per-suite mock so the hydrate reconcile point-read is observable.
+const apiMock = { getEnvironmentTest: vi.fn() }
+vi.stubGlobal('useApi', () => apiMock)
+
+/** Minimal EnvironmentTestRun factory — only the fields the store's reconcile logic touches. */
+function run(id: string, over: Partial<EnvironmentTestRun> = {}): EnvironmentTestRun {
+  return {
+    id,
+    workspaceId: 'ws_test',
+    blockId: `blk_${id}`,
+    status: 'running',
+    stage: 'provisioning',
+    branch: null,
+    envUrl: null,
+    error: null,
+    failedStage: null,
+    createdAt: 1,
+    updatedAt: 1,
+    ...over,
+  }
+}
+
+describe('environmentTest store — monotonic run reconcile', () => {
+  let store: ReturnType<typeof useEnvironmentTestStore>
+  beforeEach(() => {
+    apiMock.getEnvironmentTest = vi.fn(async () => {
+      throw new Error('not stubbed')
+    })
+    store = useEnvironmentTestStore()
+  })
+
+  it('hydrate does NOT regress a run a newer live event already advanced', () => {
+    // A live `envTest: failed` event landed first (newer updatedAt).
+    store.upsert(run('r1', { status: 'failed', failedStage: 'provisioning', updatedAt: 5 }))
+    // A lagging `workspace.refresh()` then hydrates a STALE snapshot that still saw the run
+    // as `running` (older updatedAt) — it must NOT clobber the terminal state (terminal runs
+    // emit nothing further, so the inspector would be stuck on "testing" forever).
+    store.hydrate([run('r1', { status: 'running', updatedAt: 2 })], 'ws_test')
+    expect(store.runForBlock('blk_r1')!.status).toBe('failed')
+  })
+
+  it('hydrate does NOT drop a live-added run the stale snapshot never saw', () => {
+    // Terminal runs are omitted from the snapshot BY DESIGN, so a just-finished run the
+    // inspector still shows must survive a full refresh.
+    store.upsert(run('r1', { status: 'succeeded', stage: 'done', updatedAt: 5 }))
+    store.hydrate([], 'ws_test')
+    expect(store.runForBlock('blk_r1')!.status).toBe('succeeded')
+  })
+
+  it('hydrate point-reads a preserved RUNNING run the snapshot omitted (finished offline)', async () => {
+    // The run was still `running` when the socket dropped; it finished while disconnected, so
+    // the reconnect snapshot no longer carries it and no event replays — the hydrate must
+    // re-read it to pick up the outcome instead of stranding a stale "testing" state.
+    store.upsert(run('r1', { status: 'running', updatedAt: 5 }))
+    apiMock.getEnvironmentTest = vi.fn(async () =>
+      run('r1', { status: 'succeeded', stage: 'done', updatedAt: 9 }),
+    )
+    store.hydrate([], 'ws_test')
+    expect(apiMock.getEnvironmentTest).toHaveBeenCalledWith('ws_test', 'r1')
+    await vi.waitFor(() => expect(store.runForBlock('blk_r1')!.status).toBe('succeeded'))
+  })
+
+  it('a STALE point-read cannot regress a run a live event advanced meanwhile', async () => {
+    store.upsert(run('r1', { status: 'running', updatedAt: 5 }))
+    // The reconcile read resolves with an OLDER view of the run than the live event that
+    // lands while it is in flight — the monotonic upsert must keep the newer state.
+    apiMock.getEnvironmentTest = vi.fn(async () => run('r1', { status: 'running', updatedAt: 4 }))
+    store.hydrate([], 'ws_test')
+    store.upsert(run('r1', { status: 'failed', failedStage: 'tearing_down', updatedAt: 8 }))
+    await vi.waitFor(() => expect(apiMock.getEnvironmentTest).toHaveBeenCalled())
+    await Promise.resolve()
+    expect(store.runForBlock('blk_r1')!.status).toBe('failed')
+  })
+
+  it('hydrate DROPS a cached run from a different workspace (board switch starts clean)', () => {
+    store.upsert(run('r1', { status: 'failed', updatedAt: 5, workspaceId: 'ws_other' }))
+    store.hydrate([run('r2', { workspaceId: 'ws_test' })], 'ws_test')
+    expect(store.runs.map((r) => r.id)).toEqual(['r2'])
+  })
+
+  it('hydrate DOES apply a genuinely newer snapshot', () => {
+    store.upsert(run('r1', { status: 'running', updatedAt: 2 }))
+    store.hydrate(
+      [run('r1', { status: 'running', stage: 'tearing_down', updatedAt: 9 })],
+      'ws_test',
+    )
+    expect(store.runForBlock('blk_r1')!.stage).toBe('tearing_down')
+  })
+
+  it('upsert ignores an older/out-of-order write but applies newer/equal', () => {
+    store.upsert(run('r1', { status: 'failed', updatedAt: 5 }))
+    // e.g. a `start()` response resolving AFTER the fast-failing run's terminal event landed.
+    store.upsert(run('r1', { status: 'running', stage: 'creating_branch', updatedAt: 3 }))
+    expect(store.runForBlock('blk_r1')!.status).toBe('failed')
+    store.upsert(run('r1', { status: 'succeeded', stage: 'done', updatedAt: 5 }))
+    expect(store.runForBlock('blk_r1')!.status).toBe('succeeded')
+  })
+})

package/app/stores/environmentTest.ts

@@ -0,0 +1,114 @@
+import { defineStore } from 'pinia'
+import { ref } from 'vue'
+import type { EnvironmentTestRun } from '~/types/domain'
+import { useWorkspaceStore } from '~/stores/workspace'
+
+/**
+ * Ephemeral-environment self-test runs. A developer starts one from a service frame's inspector
+ * (`POST …/blocks/:id/environment-test`); the backend drives the create-branch → provision →
+ * tear-down → delete-branch cycle durably and pushes live `envTest` stage events, which
+ * `useWorkspaceStream` folds in via {@link upsert}. In-flight runs also arrive in the workspace
+ * snapshot ({@link hydrate}) so the inspector re-attaches to a running test after a reconnect.
+ *
+ * Runs are keyed by their FRAME block id for the inspector's per-service lookup ({@link runForBlock}
+ * returns the newest run for a block). Terminal runs are kept in memory for the session so the
+ * inspector can show the last outcome; the snapshot only carries running ones.
+ */
+export const useEnvironmentTestStore = defineStore('environmentTest', () => {
+  const api = useApi()
+
+  /** All known runs (running + this session's terminal ones), newest first. */
+  const runs = ref<EnvironmentTestRun[]>([])
+
+  function sortByCreated(list: EnvironmentTestRun[]): EnvironmentTestRun[] {
+    return [...list].sort((a, b) => b.createdAt - a.createdAt)
+  }
+
+  /**
+   * Reconcile the cached runs with a server snapshot for `workspaceId`. A snapshot is
+   * authoritative EXCEPT where a live `envTest` event has already advanced (or ADDED) a run
+   * past what this (possibly stale) read observed — a `board`-event refresh or the on-connect
+   * resync can resolve AFTER a newer event already landed. Same two clobber hazards as
+   * `agentRuns.hydrate`, both handled here:
+   *   - REGRESS: a run present in BOTH the snapshot and the cache — keep the newer-by-`updatedAt`
+   *     version, so a lagging refresh can't revert a `failed`/`succeeded` run to `running`
+   *     (terminal runs emit nothing further, so the inspector would be stuck on "testing").
+   *   - DROP: a run a live event just ADDED that the (older) snapshot never saw — replacing from
+   *     the snapshot alone would silently drop it (and terminal runs are omitted from the
+   *     snapshot by design, so a finished run the inspector still shows would vanish).
+   *     Preserve such cached runs, scoped to `workspaceId` so a board SWITCH still starts clean.
+   *
+   * A preserved RUNNING run absent from the snapshot may also have reached terminal while the
+   * socket was down (no event replays, and the snapshot omits terminal runs) — point-read it
+   * best-effort to pick up the outcome; {@link upsert}'s monotonic guard makes the read safe
+   * against racing live events.
+   */
+  function hydrate(snapshotRuns: EnvironmentTestRun[], workspaceId: string) {
+    const incomingIds = new Set(snapshotRuns.map((r) => r.id))
+    const held = new Map(runs.value.map((r) => [r.id, r]))
+    const reconciled = snapshotRuns.map((incoming) => {
+      const current = held.get(incoming.id)
+      return current && current.updatedAt > incoming.updatedAt ? current : incoming
+    })
+    const preserved = [...held.values()].filter(
+      (r) => !incomingIds.has(r.id) && r.workspaceId === workspaceId,
+    )
+    runs.value = sortByCreated([...reconciled, ...preserved])
+    // A still-`running` preserved run wasn't in the snapshot, so either the snapshot is stale
+    // (the run is genuinely newer) or the run FINISHED while we were disconnected — resolve
+    // which by re-reading it (non-blocking; failures leave the cached state as-is).
+    for (const r of preserved) {
+      if (r.status === 'running') void reconcileRun(workspaceId, r.id)
+    }
+  }
+
+  /** Best-effort point-read of one run, folded in through the monotonic {@link upsert}. */
+  async function reconcileRun(workspaceId: string, id: string) {
+    try {
+      upsert(await api.getEnvironmentTest(workspaceId, id))
+    } catch {
+      // Best-effort: a transient fetch failure just leaves the cached state; the next
+      // snapshot/event reconciles it.
+    }
+  }
+
+  /**
+   * Fold a live-pushed (or freshly-started/stopped) run into the cache. Monotonic by
+   * `updatedAt`: never let a stale/out-of-order write regress a run a newer one already
+   * advanced — e.g. a `start()` response resolving AFTER a fast-failing run's terminal
+   * event already landed (same guard as {@link hydrate}).
+   */
+  function upsert(run: EnvironmentTestRun) {
+    const i = runs.value.findIndex((r) => r.id === run.id)
+    if (i >= 0) {
+      if (run.updatedAt >= runs.value[i]!.updatedAt) runs.value[i] = run
+    } else runs.value.unshift(run)
+  }
+
+  function runById(id: string): EnvironmentTestRun | undefined {
+    return runs.value.find((r) => r.id === id)
+  }
+
+  /** The newest run for a service frame — the inspector's per-service attach point. */
+  function runForBlock(blockId: string): EnvironmentTestRun | undefined {
+    return runs.value.find((r) => r.blockId === blockId)
+  }
+
+  /** Start a self-test against a service frame; the returned run is tracked immediately. */
+  async function start(blockId: string): Promise<EnvironmentTestRun> {
+    const ws = useWorkspaceStore()
+    const run = await api.startEnvironmentTest(ws.requireId(), blockId)
+    upsert(run)
+    return run
+  }
+
+  /** Stop a running self-test (best-effort cleanup, then failed). */
+  async function stop(id: string): Promise<EnvironmentTestRun> {
+    const ws = useWorkspaceStore()
+    const run = await api.stopEnvironmentTest(ws.requireId(), id)
+    upsert(run)
+    return run
+  }
+
+  return { runs, hydrate, upsert, runById, runForBlock, start, stop }
+})

package/app/stores/workspace.spec.ts

@@ -15,6 +15,7 @@ const INERT_STORES = [
   'useClarityStore',
   'useConsensusStore',
   'useDocInterviewStore',
+  'useEnvironmentTestStore',
   'useExecutionStore',
   'useFragmentsStore',
   'useGitHubStore',

package/app/stores/workspace.ts

@@ -12,6 +12,7 @@ import { useBoardStore } from '~/stores/board'
 import { usePipelinesStore } from '~/stores/pipelines'
 import { useExecutionStore } from '~/stores/execution'
 import { useAgentRunsStore } from '~/stores/agentRuns'
+import { useEnvironmentTestStore } from '~/stores/environmentTest'
 import { useNotificationsStore } from '~/stores/notifications'
 import { useRiskPoliciesStore } from '~/stores/riskPolicies'
 import { useSharedStacksStore } from '~/stores/sharedStacks'
@@ -120,6 +121,7 @@ export const useWorkspaceStore = defineStore(
       useExecutionStore().hydrate(snapshot.executions, snapshot.workspace.id)
       useAgentRunsStore().hydrate(snapshot.bootstrapJobs ?? [], snapshot.workspace.id)
       useAgentRunsStore().hydrateEnvConfigRepair(snapshot.envConfigRepairJobs ?? [])
+      useEnvironmentTestStore().hydrate(snapshot.environmentTestRuns ?? [], snapshot.workspace.id)
       useNotificationsStore().hydrate(snapshot.notifications ?? [])
       useRiskPoliciesStore().hydrate(
         snapshot.riskPolicies ?? [],

package/app/types/domain.ts

@@ -39,6 +39,9 @@ export type {
   FrontendBackendSource,
   ResolvedFrontendBinding,
   EnvironmentHandle,
+  EnvironmentTestRun,
+  EnvironmentTestStage,
+  EnvironmentTestStatus,
   ServiceConnection,
   FrontendBranch,
   FrontendPackageManager,

package/app/utils/slackMemberMapping.spec.ts

@@ -0,0 +1,94 @@
+import { describe, it, expect } from 'vitest'
+import type { SlackMemberMappingEntry } from '~/types/slack'
+import {
+  type MemberRow,
+  emptyMemberRow,
+  hasHalfFilledRow,
+  toMemberEntries,
+  toMemberRow,
+} from './slackMemberMapping'
+
+const row = (partial: Partial<MemberRow> & { uid: string }): MemberRow => ({
+  userId: '',
+  slackUserId: '',
+  role: 'engineering',
+  ...partial,
+})
+
+describe('hasHalfFilledRow', () => {
+  it('is false for fully-filled rows', () => {
+    expect(hasHalfFilledRow([row({ uid: 'a', userId: 'usr_1', slackUserId: 'U1' })])).toBe(false)
+  })
+
+  it('is false for fully-empty rows (unused slots)', () => {
+    expect(hasHalfFilledRow([row({ uid: 'a' }), row({ uid: 'b' })])).toBe(false)
+  })
+
+  it('is true when only the user id is filled', () => {
+    expect(hasHalfFilledRow([row({ uid: 'a', userId: 'usr_1' })])).toBe(true)
+  })
+
+  it('is true when only the Slack id is filled', () => {
+    expect(hasHalfFilledRow([row({ uid: 'a', slackUserId: 'U1' })])).toBe(true)
+  })
+
+  it('treats whitespace-only ids as blank', () => {
+    expect(hasHalfFilledRow([row({ uid: 'a', userId: '  ', slackUserId: 'U1' })])).toBe(true)
+  })
+
+  it('flags a half-filled row among valid ones', () => {
+    expect(
+      hasHalfFilledRow([
+        row({ uid: 'a', userId: 'usr_1', slackUserId: 'U1' }),
+        row({ uid: 'b', userId: 'usr_2' }),
+      ]),
+    ).toBe(true)
+  })
+})
+
+describe('toMemberEntries', () => {
+  it('keeps fully-filled rows, drops empty slots, and strips uid', () => {
+    const rows: MemberRow[] = [
+      row({ uid: 'a', userId: 'usr_1', slackUserId: 'U1', role: 'product' }),
+      row({ uid: 'b' }), // empty slot — dropped
+      row({ uid: 'c', userId: 'usr_2', slackUserId: 'U2' }),
+    ]
+    expect(toMemberEntries(rows)).toEqual([
+      { userId: 'usr_1', slackUserId: 'U1', role: 'product' },
+      { userId: 'usr_2', slackUserId: 'U2', role: 'engineering' },
+    ])
+  })
+
+  it('does not leak the client-only uid onto the wire payload', () => {
+    const [entry] = toMemberEntries([row({ uid: 'a', userId: 'usr_1', slackUserId: 'U1' })])
+    expect(entry).not.toHaveProperty('uid')
+  })
+})
+
+describe('toMemberRow', () => {
+  it('stamps the uid and defaults a missing role', () => {
+    const entry: SlackMemberMappingEntry = { userId: 'usr_1', slackUserId: 'U1' }
+    expect(toMemberRow(entry, 'm1')).toEqual({
+      userId: 'usr_1',
+      slackUserId: 'U1',
+      role: 'engineering',
+      uid: 'm1',
+    })
+  })
+
+  it('preserves an explicit role', () => {
+    const entry: SlackMemberMappingEntry = { userId: 'usr_1', slackUserId: 'U1', role: 'product' }
+    expect(toMemberRow(entry, 'm2').role).toBe('product')
+  })
+})
+
+describe('emptyMemberRow', () => {
+  it('builds a blank engineering row with the given uid', () => {
+    expect(emptyMemberRow('m9')).toEqual({
+      uid: 'm9',
+      userId: '',
+      slackUserId: '',
+      role: 'engineering',
+    })
+  })
+})

package/app/utils/slackMemberMapping.ts

@@ -0,0 +1,46 @@
+import type { SlackMemberMappingEntry } from '~/types/slack'
+
+// Pure helpers for the Slack member-mapping editor (SlackPanel.vue). Extracted so
+// the save-time integrity rules (UX-23) can be unit-tested without mounting the panel.
+
+/**
+ * An editable member-map row: the wire entry plus a client-only stable `uid` so a
+ * mid-list delete keys the `v-model` by identity, not the array index (index keys
+ * silently rebound a neighbour's inputs — UX-23).
+ */
+export type MemberRow = SlackMemberMappingEntry & { uid: string }
+
+/**
+ * True when any row has exactly one of the two ids filled. A half-entered mapping
+ * used to be silently dropped on save (UX-23); the panel blocks the save instead so
+ * the user doesn't lose it. A fully-empty row is an unused slot, not half-filled.
+ */
+export function hasHalfFilledRow(
+  rows: readonly Pick<MemberRow, 'userId' | 'slackUserId'>[],
+): boolean {
+  return rows.some((e) => Boolean(e.userId.trim()) !== Boolean(e.slackUserId.trim()))
+}
+
+/**
+ * The rows to persist: fully-filled only (empty slots dropped), with the client-only
+ * `uid` stripped from the wire payload.
+ */
+export function toMemberEntries(rows: readonly MemberRow[]): SlackMemberMappingEntry[] {
+  return rows
+    .filter((e) => e.userId.trim() && e.slackUserId.trim())
+    .map(({ uid: _uid, ...entry }) => entry)
+}
+
+/**
+ * Wrap a stored wire entry as an editable row: stamp a stable `uid` and default the
+ * `role` (absent on older maps) so the initial load and the post-save reload produce
+ * identical rows rather than drifting on the default.
+ */
+export function toMemberRow(entry: SlackMemberMappingEntry, uid: string): MemberRow {
+  return { role: 'engineering', ...entry, uid }
+}
+
+/** A fresh, empty editable row stamped with the given stable `uid`. */
+export function emptyMemberRow(uid: string): MemberRow {
+  return { uid, userId: '', slackUserId: '', role: 'engineering' }
+}

package/i18n/locales/de.json

@@ -1093,6 +1093,23 @@
         "title": "Einrichtung der Compose-Umgebung",
         "hint": "Konfiguriere das Rezept, die Preflights und den Handler, damit der Deployer diesen Stack bereitstellt.",
         "open": "Assistent öffnen"
+      },
+      "envTest": {
+        "title": "Umgebungserstellung testen",
+        "hint": "Führt den gesamten Lebenszyklus gegen einen Wegwerf-Branch aus: Branch erstellen, bereitstellen, abbauen, Branch löschen.",
+        "start": "Umgebungserstellung testen",
+        "stop": "Stopp",
+        "infraless": "Konfiguriere oben einen Bereitstellungstyp, um die Umgebungserstellung zu testen.",
+        "running": "Wird getestet: {stage}",
+        "succeeded": "Test bestanden: Die Umgebung wurde erstellt und abgebaut, und der Branch wurde gelöscht.",
+        "failed": "Test fehlgeschlagen",
+        "stage": {
+          "creating_branch": "Branch wird erstellt",
+          "provisioning": "Umgebung wird bereitgestellt",
+          "tearing_down": "Umgebung wird abgebaut",
+          "deleting_branch": "Branch wird gelöscht",
+          "done": "fertig"
+        }
       }
     },
     "agentConfig": {
@@ -3368,6 +3385,11 @@
       "title": "Dieses Fragment löschen?",
       "body": "\"{name}\" wird entfernt. Dies kann nicht rückgängig gemacht werden."
     },
+    "confirmUnlinkSource": {
+      "title": "Diese Quelle trennen?",
+      "body": "„{repo}“ und die davon synchronisierten Richtlinien-Fragmente werden entfernt. Du kannst sie später erneut verknüpfen.",
+      "confirm": "Trennen"
+    },
     "unavailable": "Die Prompt-Fragment-Bibliothek ist für dieses Deployment nicht aktiviert."
   },
   "brainstorm": {
@@ -3781,7 +3803,11 @@
         "visual_pipeline_no_frontend": "Kein Frontend zum Testen",
         "model_policy_blocked": "Modell durch Kontorichtlinie blockiert",
         "model_policy_unsupported": "Modellrichtlinie hier nicht verfügbar",
-        "deployer_required_before_tester": "Füge einen Deployer vor dem Tester hinzu"
+        "deployer_required_before_tester": "Füge einen Deployer vor dem Tester hinzu",
+        "env_test_not_a_frame": "Kein Dienst",
+        "env_test_infraless": "Nichts zu testen",
+        "env_test_not_provisionable": "Umgebungs-Handler nicht konfiguriert",
+        "env_test_no_vcs": "Git-Anbieter nicht verbunden"
       },
       "fallbackMessage": "Diese Aktion steht im Konflikt mit dem aktuellen Zustand.",
       "providersUnconfigured": {
@@ -3838,7 +3864,9 @@
       "userIdPlaceholder": "Benutzer-ID (usr_...)",
       "slackIdPlaceholder": "Slack-Mitglieds-ID (U...)",
       "add": "Mitglied hinzufügen",
-      "save": "Zuordnung speichern"
+      "save": "Zuordnung speichern",
+      "incompleteTitle": "Unvollständige Mitgliederzeile",
+      "incompleteBody": "Gib vor dem Speichern sowohl die Benutzer-ID als auch die Slack-Mitglieds-ID ein oder entferne die Zeile."
     },
     "routable": {
       "merge_review": "Merge-Review",

package/i18n/locales/en.json

@@ -475,7 +475,11 @@
         "visual_pipeline_no_frontend": "No frontend to test",
         "model_policy_blocked": "Model blocked by account policy",
         "model_policy_unsupported": "Model policy not available here",
-        "deployer_required_before_tester": "Add a Deployer before the Tester"
+        "deployer_required_before_tester": "Add a Deployer before the Tester",
+        "env_test_not_a_frame": "Not a service",
+        "env_test_infraless": "Nothing to test",
+        "env_test_not_provisionable": "Environment handler not configured",
+        "env_test_no_vcs": "Git provider not connected"
       },
       "fallbackMessage": "This action conflicts with the current state.",
       "providersUnconfigured": {
@@ -837,6 +841,23 @@
         "title": "Compose environment setup",
         "hint": "Configure the recipe, preflights, and handler so the Deployer provisions this stack.",
         "open": "Open wizard"
+      },
+      "envTest": {
+        "title": "Test environment creation",
+        "hint": "Runs the whole lifecycle against a throwaway branch: create branch, provision, tear down, delete branch.",
+        "start": "Test environment creation",
+        "stop": "Stop",
+        "infraless": "Configure a provision type above to test environment creation.",
+        "running": "Testing: {stage}",
+        "succeeded": "Test passed: the environment was created and torn down, and the branch was deleted.",
+        "failed": "Test failed",
+        "stage": {
+          "creating_branch": "creating branch",
+          "provisioning": "provisioning environment",
+          "tearing_down": "tearing down environment",
+          "deleting_branch": "deleting branch",
+          "done": "done"
+        }
       }
     },
     "agentConfig": {
@@ -2986,7 +3007,9 @@
       "userIdPlaceholder": "User id (usr_...)",
       "slackIdPlaceholder": "Slack member id (U...)",
       "add": "Add member",
-      "save": "Save map"
+      "save": "Save map",
+      "incompleteTitle": "Incomplete member row",
+      "incompleteBody": "Fill in both the user id and the Slack member id, or remove the row, before saving."
     },
     "routable": {
       "merge_review": "Merge review",
@@ -4319,6 +4342,11 @@
       "title": "Delete this fragment?",
       "body": "\"{name}\" will be removed. This can't be undone."
     },
+    "confirmUnlinkSource": {
+      "title": "Unlink this source?",
+      "body": "\"{repo}\" and the guideline fragments it synced will be removed. You can re-link it later.",
+      "confirm": "Unlink"
+    },
     "unavailable": "The prompt-fragment library isn't enabled for this deployment."
   },
   "sandbox": {

package/i18n/locales/es.json

@@ -436,7 +436,11 @@
         "visual_pipeline_no_frontend": "No hay frontend que probar",
         "model_policy_blocked": "Modelo bloqueado por la política de la cuenta",
         "model_policy_unsupported": "La política de modelos no está disponible aquí",
-        "deployer_required_before_tester": "Añade un Deployer antes del Tester"
+        "deployer_required_before_tester": "Añade un Deployer antes del Tester",
+        "env_test_not_a_frame": "No es un servicio",
+        "env_test_infraless": "Nada que probar",
+        "env_test_not_provisionable": "Gestor de entorno no configurado",
+        "env_test_no_vcs": "Proveedor de Git no conectado"
       },
       "fallbackMessage": "Esta acción entra en conflicto con el estado actual.",
       "providersUnconfigured": {
@@ -783,6 +787,23 @@
         "title": "Configuración de entorno Compose",
         "hint": "Configura la receta, las comprobaciones previas y el gestor para que el Deployer aprovisione este stack.",
         "open": "Abrir asistente"
+      },
+      "envTest": {
+        "title": "Probar la creación del entorno",
+        "hint": "Ejecuta todo el ciclo de vida sobre una rama desechable: crear rama, aprovisionar, desmontar, eliminar rama.",
+        "start": "Probar la creación del entorno",
+        "stop": "Detener",
+        "infraless": "Configura arriba un tipo de aprovisionamiento para probar la creación del entorno.",
+        "running": "Probando: {stage}",
+        "succeeded": "Prueba superada: el entorno se creó y se desmontó, y la rama se eliminó.",
+        "failed": "La prueba falló",
+        "stage": {
+          "creating_branch": "creando rama",
+          "provisioning": "aprovisionando entorno",
+          "tearing_down": "desmontando entorno",
+          "deleting_branch": "eliminando rama",
+          "done": "listo"
+        }
       }
     },
     "agentConfig": {
@@ -2899,7 +2920,9 @@
       "userIdPlaceholder": "Id de usuario (usr_...)",
       "slackIdPlaceholder": "Id de miembro de Slack (U...)",
       "add": "Anadir miembro",
-      "save": "Guardar mapa"
+      "save": "Guardar mapa",
+      "incompleteTitle": "Fila de miembro incompleta",
+      "incompleteBody": "Antes de guardar, completa tanto el id de usuario como el id de miembro de Slack, o elimina la fila."
     },
     "routable": {
       "merge_review": "Revision de fusion",
@@ -4152,6 +4175,11 @@
       "title": "¿Eliminar este fragmento?",
       "body": "Se eliminará \"{name}\". Esta acción no se puede deshacer."
     },
+    "confirmUnlinkSource": {
+      "title": "¿Desvincular esta fuente?",
+      "body": "«{repo}» y los fragmentos de directrices que sincronizó se eliminarán. Puedes volver a vincularla más tarde.",
+      "confirm": "Desvincular"
+    },
     "unavailable": "La biblioteca de fragmentos de prompt no está habilitada en esta implementación."
   },
   "sandbox": {

package/i18n/locales/fr.json

@@ -436,7 +436,11 @@
         "visual_pipeline_no_frontend": "Aucun frontend à tester",
         "model_policy_blocked": "Modèle bloqué par la politique du compte",
         "model_policy_unsupported": "La politique de modèles n'est pas disponible ici",
-        "deployer_required_before_tester": "Ajoutez un Deployer avant le Testeur"
+        "deployer_required_before_tester": "Ajoutez un Deployer avant le Testeur",
+        "env_test_not_a_frame": "Pas un service",
+        "env_test_infraless": "Rien à tester",
+        "env_test_not_provisionable": "Gestionnaire d'environnement non configuré",
+        "env_test_no_vcs": "Fournisseur Git non connecté"
       },
       "fallbackMessage": "Cette action est en conflit avec l’état actuel.",
       "providersUnconfigured": {
@@ -783,6 +787,23 @@
         "title": "Configuration d'environnement Compose",
         "hint": "Configurez la recette, les vérifications préalables et le gestionnaire pour que le Deployer provisionne cette stack.",
         "open": "Ouvrir l'assistant"
+      },
+      "envTest": {
+        "title": "Tester la création de l'environnement",
+        "hint": "Exécute tout le cycle de vie sur une branche jetable : créer la branche, provisionner, démonter, supprimer la branche.",
+        "start": "Tester la création de l'environnement",
+        "stop": "Arrêter",
+        "infraless": "Configurez un type de provisionnement ci-dessus pour tester la création de l'environnement.",
+        "running": "Test en cours : {stage}",
+        "succeeded": "Test réussi : l'environnement a été créé puis démonté, et la branche a été supprimée.",
+        "failed": "Échec du test",
+        "stage": {
+          "creating_branch": "création de la branche",
+          "provisioning": "provisionnement de l'environnement",
+          "tearing_down": "démontage de l'environnement",
+          "deleting_branch": "suppression de la branche",
+          "done": "terminé"
+        }
       }
     },
     "agentConfig": {
@@ -2899,7 +2920,9 @@
       "userIdPlaceholder": "Id utilisateur (usr_...)",
       "slackIdPlaceholder": "Id de membre Slack (U...)",
       "add": "Ajouter un membre",
-      "save": "Enregistrer la carte"
+      "save": "Enregistrer la carte",
+      "incompleteTitle": "Ligne de membre incomplète",
+      "incompleteBody": "Avant d’enregistrer, renseignez l’id utilisateur et l’id de membre Slack, ou supprimez la ligne."
     },
     "routable": {
       "merge_review": "Revue de fusion",
@@ -4152,6 +4175,11 @@
       "title": "Supprimer ce fragment ?",
       "body": "\"{name}\" sera supprimé. Cette action est irréversible."
     },
+    "confirmUnlinkSource": {
+      "title": "Dissocier cette source ?",
+      "body": "« {repo} » et les fragments de directives qu’elle a synchronisés seront supprimés. Vous pourrez la relier plus tard.",
+      "confirm": "Dissocier"
+    },
     "unavailable": "La bibliothèque de fragments de prompt n'est pas activée pour ce déploiement."
   },
   "sandbox": {