@cat-factory/app 0.216.0 → 0.217.1

package/README.md

@@ -79,6 +79,29 @@ earlier than before takes the entire SPA down at boot, and the unit suite cannot
 (nothing there installs the plugin). Every e2e spec does, because every one of them boots
 the app.
 
+### A backend-DECLARED form renders through `DescriptorFields.vue`
+
+When the backend declares the fields and the SPA only collects them, render them with the shared
+`components/common/DescriptorFields.vue` over the contracts vocabulary
+(`contracts/src/form-fields.ts`), and never hand-roll a second renderer for the same shapes. Two
+surfaces use it: an initiative preset's create form and a reusable operation's per-case form on a
+custom task type (`AddTaskModal`). Adding a third is a `:fields` binding, not a component.
+
+Four rules travel with it. **Validate with the shared `validateDescriptorFields`** so the submit
+button reflects exactly what the server will refuse, and **submit the shared
+`sanitizeDescriptorFields` result** so a stale answer on a since-hidden `showWhen` field never
+reaches the wire. **The labels are deployment-authored English rendered verbatim**: only the chrome
+around them (a path-invalid message, section captions) is i18n, so no descriptor string enters a
+locale catalog. And **the value-bag rules live in `utils/descriptorFields.ts`, not in the SFC**
+(`defaultDescriptorValues` for the initial values, `setDescriptorValue` / `setDescriptorCheckbox` /
+`toggleDescriptorGroupValue` for one edit): what an edit freezes on an entity is what a unit test
+must be able to reach, and a rule inside a component is only reachable by mounting one.
+
+Mirroring the server's check leaves one refusal still reachable, deliberately: the deployment can
+re-register the descriptor while the dialog sits open, so a create can come back `422` with
+`details.reason: 'task_type_fields_invalid'`. Map it to translated copy like any other reason
+(`AddTaskModal`'s `createRefusalMessage`) rather than showing the server's field-key prose.
+
 ### Always import a layer component explicitly
 
 **Import a component under `components/` by path before using it in a template.** Do not lean on Nuxt's auto-registration. This layer sets no `components` config, so the default `pathPrefix: true` applies and a component is registered under its path-prefixed name: `components/panels/StepEffortReport.vue` becomes `PanelsStepEffortReport`, and a bare `<StepEffortReport>` matches nothing.
@@ -135,7 +158,7 @@ hoc where it can be avoided:
     and the deployment-wide operator + reports rollups).
 
   Sole-route items stay in basic when the delivery loop runs on them: the pipeline builder,
-  add-from-repo, the fragment library, the infrastructure/PREnv windows, and the workspace /
+  add-from-repo, the fragment library, the infrastructure/ephemeral-env windows, and the workspace /
   model configuration a run actually reads. `nav-contributions.spec.ts` pins the advanced set
   against a table naming each item's kind and reason, so promoting one forces that claim to be
   written down rather than assumed.

package/app/components/board/AddTaskModal.vue

@@ -15,6 +15,7 @@
 // (see useContextLinking) — the same context the agents see for every step of the run.
 import type {
   CreateTaskType,
+  DescriptorFieldValues,
   DocKind,
   DocKindFieldKey,
   TaskSourceKind,
@@ -25,11 +26,14 @@ import { resolveComponentRegistry } from '@modular-vue/core'
 import { useReactiveSlots } from '@modular-vue/runtime'
 import type { AppSlots, ResultViewContribution } from '~/modular/slots'
 import ContextAttachmentFields from '~/components/context/ContextAttachmentFields.vue'
+import DescriptorFields from '~/components/common/DescriptorFields.vue'
 import FragmentSelector from '~/components/fragments/FragmentSelector.vue'
 import RiskPolicyPicker from '~/components/riskPolicy/RiskPolicyPicker.vue'
 import { parseConflict } from '~/composables/usePipelineErrorToast'
 import { apiErrorEnvelope } from '~/composables/api/errors'
 import type { ReviewTargetReason } from '@cat-factory/contracts'
+import { sanitizeDescriptorFields, validateDescriptorFields } from '@cat-factory/contracts'
+import { defaultDescriptorValues } from '~/utils/descriptorFields'
 import { pipelineAllowedForManualStart } from '~/utils/pipeline'
 
 const ui = useUiStore()
@@ -155,8 +159,9 @@ const selectedCustomType = computed(() =>
   customTaskTypes.value.find((tt) => tt.taskType === taskType.value),
 )
 // Descriptor-field values for a selected custom type (or a bespoke form panel's own bag), folded
-// into `taskTypeFields.custom` on submit. Cleared when the type changes / the modal reopens.
-const customFieldValues = ref<Record<string, string | number>>({})
+// into `taskTypeFields.custom` on submit. Re-seeded to the descriptor's own defaults when the type
+// changes / the modal reopens (its fields differ per type, so a carried-over bag would be foreign).
+const customFieldValues = ref<DescriptorFieldValues>({})
 // A bespoke create-form section paired to the custom type's `formPanel` id via the
 // `taskTypeFormPanels` slot; shown INSTEAD of the descriptor fields. Unpaired ⇒ descriptor fields
 // (degrade, never crash) — the same pairing shape as the result-view windows.
@@ -168,19 +173,15 @@ const customFormPanel = computed(() => {
   const id = selectedCustomType.value?.formPanel
   return id ? (formPanelRegistry.value.get(id) ?? null) : null
 })
-// Whether every REQUIRED descriptor field of the selected custom type has a value. Only the
-// descriptor path is enforced up front — a bespoke `formPanel` owns its own validation, so we
-// don't block on it (nor can we read its required semantics). No custom type selected (or none
-// of its fields are required) ⇒ trivially satisfied. Folded into `canAdd` so the required marker
-// the form renders is actually honoured before submit.
-const customRequiredFieldsFilled = computed(() => {
+// Client-side mirror of the server's creation check (the SAME shared function `BoardService` runs),
+// so the submit button reflects an invalid form: a missing required answer, a value outside its
+// declared options, an over-long string. Only the descriptor path is checked up front, since a
+// bespoke `formPanel` owns its own validation and the platform cannot read its required semantics.
+// The per-field path error is rendered inline by `DescriptorFields`.
+const customFieldProblems = computed(() => {
   const custom = selectedCustomType.value
-  if (!custom || customFormPanel.value) return true
-  return (custom.fields ?? []).every((field) => {
-    if (!field.required) return true
-    const raw = customFieldValues.value[field.key]
-    return raw !== undefined && String(raw).trim() !== ''
-  })
+  if (!custom || customFormPanel.value) return []
+  return validateDescriptorFields(custom.fields ?? [], customFieldValues.value)
 })
 // The type picker: the built-in choices (i18n labels) + the custom types (their wire presentation).
 const typeChoices = computed<{ value: TaskTypeChoice; label: string; icon: string }[]>(() => [
@@ -258,28 +259,21 @@ const DOC_FIELD_PLACEHOLDER_KEYS: Record<DocKindFieldKey, string> = {
 const SEVERITIES = ['low', 'medium', 'high', 'critical'] as const
 
 // A CUSTOM (deployment-registered) task type: fold the collected values into the sparse
-// `taskTypeFields.custom` bag. A bespoke form panel owns the whole bag (taken verbatim); the
-// descriptor path reads only the declared fields, coercing a `number` descriptor's string input.
+// `taskTypeFields.custom` bag. A bespoke form panel owns the whole bag (taken verbatim, minus blank
+// entries); the descriptor path sends the SANITIZED subset (declared, currently-visible fields), so
+// a stale answer on a since-hidden `showWhen` field never reaches the wire. The renderer already
+// keeps each value in its contract shape, so nothing needs coercing here.
 function buildCustomTypeFields(): TaskTypeFields | undefined {
   const custom = selectedCustomType.value
   if (!custom) return undefined
-  const bag: Record<string, string | number> = {}
+  let bag: DescriptorFieldValues
   if (customFormPanel.value) {
+    bag = {}
     for (const [key, value] of Object.entries(customFieldValues.value)) {
       if (value !== undefined && value !== '') bag[key] = value
     }
   } else {
-    for (const field of custom.fields ?? []) {
-      const raw = customFieldValues.value[field.key]
-      if (raw === undefined || raw === '') continue
-      if (field.type === 'number') {
-        // Skip a non-numeric value rather than sending NaN (which serialises to null on the wire).
-        const n = Number(raw)
-        if (Number.isFinite(n)) bag[field.key] = n
-      } else {
-        bag[field.key] = raw
-      }
-    }
+    bag = sanitizeDescriptorFields(custom.fields ?? [], customFieldValues.value)
   }
   return Object.keys(bag).length ? { custom: bag } : undefined
 }
@@ -416,12 +410,13 @@ const DEFAULT_PIPELINE_FOR_TYPE: Partial<Record<TaskTypeChoice, string>> = {
   review: 'pl_review',
 }
 watch(taskType, (next) => {
-  // A custom type owns a fresh field bag on every switch (its descriptors differ per type).
-  customFieldValues.value = {}
+  const custom = customTaskTypes.value.find((tt) => tt.taskType === next)
+  // A custom type owns a fresh field bag on every switch (its descriptors differ per type), seeded
+  // to whatever defaults the new type declares.
+  customFieldValues.value = defaultDescriptorValues(custom?.fields ?? [])
   // Pre-select the type's default pipeline: a custom type's registered `defaultPipelineId`, else
   // the built-in map. (For a custom type with no default, `BoardService` applies the registry
   // default at creation, so leaving the picker unset is fine.)
-  const custom = customTaskTypes.value.find((tt) => tt.taskType === next)
   const preset = custom?.defaultPipelineId ?? DEFAULT_PIPELINE_FOR_TYPE[next]
   if (!preset) return
   const match = pipelines.pipelines.find((p) => p.id === preset)
@@ -526,6 +521,9 @@ watch(open, (isOpen) => {
   docOutlineHints.value = ''
   reviewPrRef.value = ''
   reviewFocus.value = ''
+  // Empty rather than default-seeded: `taskType` was just reset to a BUILT-IN above, which
+  // declares no descriptor fields. Picking a custom type from here runs the `taskType` watcher,
+  // and that is the one place the new type's declared defaults are seeded.
   customFieldValues.value = {}
   // Pre-seed the best-practice fragments from the enclosing service's standards, so a new task
   // ships with its service's fragments already selected (and freely add/removable here). The task
@@ -610,8 +608,8 @@ const canAdd = computed(() => {
     configValue(RALPH_VALIDATION_COMMAND_ID, '').trim().length === 0
   )
     return false
-  // A custom type's required descriptor fields must be filled (its form renders them as required).
-  if (!customRequiredFieldsFilled.value) return false
+  // A custom type's collected form must satisfy its descriptor (the same rule the server enforces).
+  if (customFieldProblems.value.length > 0) return false
   return true
 })
 
@@ -684,7 +682,7 @@ async function submitCreate(acknowledgeReviewDebt: boolean) {
     }
     toast.add({
       title: t('board.addTask.addFailedTitle'),
-      description: reviewTargetMessage(e) ?? (e instanceof Error ? e.message : String(e)),
+      description: createRefusalMessage(e) ?? (e instanceof Error ? e.message : String(e)),
       icon: 'i-lucide-triangle-alert',
       color: 'error',
     })
@@ -714,10 +712,22 @@ const REVIEW_TARGET_MESSAGES: Record<
       : null,
 }
 
-function reviewTargetMessage(error: unknown): string | null {
+/**
+ * Translated copy for a machine-readable creation refusal, or null to fall back to the server's
+ * own English prose. Two reasons are recognised: a review task's unresolvable target PR, and a
+ * custom type's collected values contradicting its descriptor.
+ *
+ * The second one is reachable here even though `canAdd` mirrors the same check client-side, and
+ * that is the whole point of the server-side check: the descriptor can be re-registered while this
+ * dialog sits open, so the form the user filled is not the form the server now validates against.
+ * The individual problems stay out of the copy: they are backend English naming field keys, so
+ * what the user is told is the ONE thing they can act on (reopen the dialog).
+ */
+function createRefusalMessage(error: unknown): string | null {
   const details = (apiErrorEnvelope(error)?.details ?? {}) as Record<string, unknown>
   const reason = details.reason
   if (typeof reason !== 'string') return null
+  if (reason === 'task_type_fields_invalid') return t('board.addTask.customFieldsInvalid')
   return REVIEW_TARGET_MESSAGES[reason as ReviewTargetReason]?.(details) ?? null
 }
 
@@ -1045,8 +1055,9 @@ function openReviewFrictionDialog(conflict: NonNullable<ReturnType<typeof parseC
 
           <!-- A CUSTOM (deployment-registered) task type: a bespoke create-form section when its
                `formPanel` is paired to the `taskTypeFormPanels` slot, else the descriptor-driven
-               `fields` the type declares. None of the built-in `v-if` branches above match a
-               namespaced custom type, so this renders on its own. -->
+               `fields` the type declares, rendered by the SHARED renderer the initiative-preset form
+               uses. None of the built-in `v-if` branches above match a namespaced custom type, so
+               this renders on its own. -->
           <div v-if="selectedCustomType" class="space-y-3" data-testid="custom-task-fields">
             <component
               :is="customFormPanel"
@@ -1055,47 +1066,12 @@ function openReviewFrictionDialog(conflict: NonNullable<ReturnType<typeof parseC
               :model-value="customFieldValues"
               @update:model-value="customFieldValues = $event"
             />
-            <template v-else>
-              <UFormField
-                v-for="field in selectedCustomType.fields ?? []"
-                :key="field.key"
-                :label="field.label"
-                :help="field.help"
-                :required="field.required"
-              >
-                <div v-if="field.type === 'select'" class="flex flex-wrap gap-1">
-                  <UButton
-                    v-for="opt in field.options ?? []"
-                    :key="opt.value"
-                    :color="customFieldValues[field.key] === opt.value ? 'primary' : 'neutral'"
-                    :variant="customFieldValues[field.key] === opt.value ? 'soft' : 'ghost'"
-                    size="xs"
-                    :data-testid="`custom-field-${field.key}-${opt.value}`"
-                    @click="() => (customFieldValues[field.key] = opt.value)"
-                  >
-                    {{ opt.label }}
-                  </UButton>
-                </div>
-                <UTextarea
-                  v-else-if="field.type === 'textarea'"
-                  v-model="customFieldValues[field.key]"
-                  :rows="2"
-                  :maxlength="field.maxLength"
-                  :placeholder="field.placeholder"
-                  :data-testid="`custom-field-${field.key}`"
-                  class="w-full"
-                />
-                <UInput
-                  v-else
-                  v-model="customFieldValues[field.key]"
-                  :type="field.type === 'number' ? 'number' : 'text'"
-                  :maxlength="field.maxLength"
-                  :placeholder="field.placeholder"
-                  :data-testid="`custom-field-${field.key}`"
-                  class="w-full"
-                />
-              </UFormField>
-            </template>
+            <DescriptorFields
+              v-else
+              v-model="customFieldValues"
+              :fields="selectedCustomType.fields ?? []"
+              testid-prefix="custom-field"
+            />
           </div>
 
           <!-- One column in basic mode, where the pipeline picker is the only survivor and a

package/app/components/board/CreateInitiativeModal.vue

@@ -6,7 +6,8 @@
 // sanitized) preset inputs on the entity. Nothing is planned here: the user then runs the preset's
 // planning pipeline on the block from the inspector.
 //
-// The preset form is rendered GENERICALLY from `descriptor.fields` (InitiativePresetFields) — zero
+// The preset form is rendered GENERICALLY from `descriptor.fields` by the shared
+// `DescriptorFields` renderer (the same one a custom task type's per-case form uses): zero
 // per-preset frontend code. A preset with a repo-detection probe prefills its form from the frame's
 // repo on selection (best-effort; failures fall back to descriptor defaults and never block create).
 //
@@ -20,9 +21,9 @@ import {
   validateInitiativePresetInputs,
 } from '@cat-factory/contracts'
 import type { InitiativePresetInputs, InitiativePresetInputValue } from '~/types/domain'
-import { defaultPresetInputs } from '~/utils/initiative'
+import { defaultDescriptorValues } from '~/utils/descriptorFields'
 import { GENERIC_PRESET_ID } from '~/stores/initiative'
-import InitiativePresetFields from '~/components/board/InitiativePresetFields.vue'
+import DescriptorFields from '~/components/common/DescriptorFields.vue'
 import ContextAttachmentFields from '~/components/context/ContextAttachmentFields.vue'
 import type { PendingContext } from '~/composables/useContextLinking'
 
@@ -62,7 +63,7 @@ let probeSeq = 0
 /** Seed the form to the selected preset's descriptor defaults, then fire its detection probe. */
 function applyPreset(): void {
   const descriptor = selectedPreset.value
-  inputs.value = descriptor ? defaultPresetInputs(descriptor) : {}
+  inputs.value = descriptor ? defaultDescriptorValues(descriptor.fields) : {}
   void runProbe()
 }
 
@@ -227,10 +228,11 @@ async function create() {
         </UFormField>
 
         <!-- The preset's descriptor-driven form (renders nothing for the fieldless generic preset). -->
-        <InitiativePresetFields
+        <DescriptorFields
           v-if="selectedPreset"
           v-model="inputs"
-          :descriptor="selectedPreset"
+          :fields="selectedPreset.fields"
+          testid-prefix="initiative-preset-field"
         />
 
         <!-- Attached requirements / issues, staged here and linked once the block exists. The

package/app/components/{board/InitiativePresetFields.vue → common/DescriptorFields.vue}

@@ -1,68 +1,68 @@
 <script setup lang="ts">
-// Generic, descriptor-driven renderer for an initiative preset's create-time FORM. Extends the
-// `ProviderConnectionTab.vue` flat-field pattern with the three shapes a preset form adds:
-// `checkbox-group` (multi-select → `string[]`), `path` (a repo-relative dir with inline
-// safety validation), and single-condition `showWhen` visibility. Every preset renders through
-// THIS component with zero per-preset frontend code — the backend descriptor supplies the fields
-// (labels/help/options are backend-supplied English, per the `describeConfig` convention). The
-// model is the typed `InitiativePresetInputs` map (scalars stay strings, `number` a number,
-// `checkbox` a boolean, `checkbox-group` a `string[]`) so it round-trips the wire contract and the
-// shared `validateInitiativePresetInputs` unchanged.
+// Generic, descriptor-driven form renderer: ONE component behind every surface where the BACKEND
+// declares the fields and the SPA only collects them. Two use it today, and they used to carry
+// near-duplicate renderers of the same vocabulary:
+//
+//   - an initiative PRESET's create-time form (`CreateInitiativeModal`)
+//   - a reusable OPERATION's per-case brief on a custom task type (`AddTaskModal`)
+//
+// It extends `ProviderConnectionTab.vue`'s flat-field pattern with the shapes a declared form needs:
+// `checkbox-group` (multi-select whose value is `string[]`), `path` (a repo-relative dir with inline
+// safety validation), and single-condition `showWhen` visibility. Labels/help/option captions are
+// backend-supplied English (the `describeConfig` convention); only the chrome is i18n.
+//
+// The model is the typed `DescriptorFieldValues` map (scalars stay strings, `number` a number,
+// `checkbox` a boolean, `checkbox-group` a `string[]`), so it round-trips the wire contract and the
+// shared `validateDescriptorFields` / `sanitizeDescriptorFields` rules unchanged.
 import { computed } from 'vue'
-import { isPresetFieldVisible, isSafeRepoDirPath } from '@cat-factory/contracts'
-import type {
-  InitiativePresetDescriptor,
-  InitiativePresetField,
-  InitiativePresetInputs,
-  InitiativePresetInputValue,
-} from '~/types/domain'
+import { isDescriptorFieldVisible, isSafeRepoDirPath } from '@cat-factory/contracts'
+import type { DescriptorField, DescriptorFieldValue, DescriptorFieldValues } from '~/types/domain'
+import {
+  descriptorGroupValue,
+  setDescriptorCheckbox,
+  setDescriptorValue,
+  toggleDescriptorGroupValue,
+} from '~/utils/descriptorFields'
 
-const props = defineProps<{ descriptor: InitiativePresetDescriptor }>()
-const model = defineModel<InitiativePresetInputs>({ required: true })
+const props = withDefaults(
+  defineProps<{
+    /** The fields to render, in declaration order (a preset's `fields`, a task type's `fields`). */
+    fields: readonly DescriptorField[]
+    /**
+     * Prefix for each field's `data-testid`, so a spec targets a field by the SURFACE it is on
+     * (`custom-field-entity`) rather than by which component happens to render it.
+     */
+    testidPrefix?: string
+  }>(),
+  { testidPrefix: 'descriptor-field' },
+)
+const model = defineModel<DescriptorFieldValues>({ required: true })
 const { t } = useI18n()
 
 // Only fields whose `showWhen` holds against the current values are shown; a hidden field's stale
 // value is kept in the model (so re-showing restores it) but the server + client both drop it at
 // sanitize/validate time, so it can never freeze an unvalidated value.
 const visibleFields = computed(() =>
-  props.descriptor.fields.filter((f) => isPresetFieldVisible(f, model.value)),
+  props.fields.filter((f) => isDescriptorFieldVisible(f, model.value)),
 )
 
-/**
- * An "empty" value that must stay ABSENT from the model rather than freeze on the entity: an
- * unchecked (`false`) checkbox, a blank string, or an empty multi-select. A numeric `0` is a real
- * value and is kept (strict `=== false`/`=== ''` never match it).
- */
-function isEmptyValue(value: InitiativePresetInputValue): boolean {
-  return value === false || value === '' || (Array.isArray(value) && value.length === 0)
+// The value-mutation rules live in `utils/descriptorFields.ts` as pure functions over the bag (what
+// an edit does to it, including the drop-when-empty rule that keeps an unset answer from freezing),
+// so they are unit-tested without mounting this component. Here they are only bound to the model.
+function set(key: string, value: DescriptorFieldValue | undefined): void {
+  model.value = setDescriptorValue(model.value, key, value)
+}
+
+function setCheckbox(field: DescriptorField, checked: boolean): void {
+  model.value = setDescriptorCheckbox(model.value, field, checked)
 }
 
-/**
- * Immutably set one field's value on the model, DROPPING empty values so a cleared field never
- * freezes an empty `''`/`[]`/`false` (mirrors `ProviderConnectionTab`'s delete-when-blank and what
- * the shared `validate`/`sanitize` treat as unset — an unchecked box / blank field stays absent).
- */
-function set(key: string, value: InitiativePresetInputValue | undefined): void {
-  const next = { ...model.value }
-  if (value === undefined || isEmptyValue(value)) delete next[key]
-  else next[key] = value
-  model.value = next
+function toggleGroup(key: string, option: string, checked: boolean): void {
+  model.value = toggleDescriptorGroupValue(model.value, key, option, checked)
 }
 
-/**
- * Set a checkbox value. A checkbox whose descriptor default is ON (`default: 'true'`) must be able
- * to persist an explicit `false`: {@link set} otherwise drops a `false` (an off box "stays unset"),
- * which for a default-ON field is indistinguishable from "untouched, still on" — so a consumer that
- * reads the opt-out as `humanReview !== false` (e.g. `seedMigrationPlan`) could never observe the
- * unchecked state and the toggle would be dead. A default-OFF checkbox keeps the drop-when-false
- * behaviour (absent === unchecked), so it never freezes a redundant `false`.
- */
-function setCheckbox(field: InitiativePresetField, checked: boolean): void {
-  if (!checked && field.default === 'true') {
-    model.value = { ...model.value, [field.key]: false }
-    return
-  }
-  set(field.key, checked)
+function groupValue(key: string): string[] {
+  return descriptorGroupValue(model.value, key)
 }
 
 function stringValue(key: string): string {
@@ -76,24 +76,15 @@ function numberStr(key: string): string {
   const v = model.value[key]
   return typeof v === 'number' ? String(v) : ''
 }
-function groupValue(key: string): string[] {
-  const v = model.value[key]
-  return Array.isArray(v) ? v : []
-}
-
-function toggleGroup(key: string, option: string, checked: boolean): void {
-  const current = groupValue(key)
-  set(key, checked ? [...new Set([...current, option])] : current.filter((o) => o !== option))
-}
 
 /** A `path` field is flagged only when non-empty AND unsafe (empty is handled by `required`). */
-function pathInvalid(field: InitiativePresetField): boolean {
+function pathInvalid(field: DescriptorField): boolean {
   if (field.type !== 'path') return false
   const value = stringValue(field.key)
   return value.trim().length > 0 && !isSafeRepoDirPath(value)
 }
 
-function selectItems(field: InitiativePresetField) {
+function selectItems(field: DescriptorField) {
   return (field.options ?? []).map((o) => ({ label: o.label, value: o.value }))
 }
 </script>
@@ -106,8 +97,8 @@ function selectItems(field: InitiativePresetField) {
       :label="field.label"
       :help="field.help"
       :required="field.required"
-      :error="pathInvalid(field) ? t('initiative.create.pathInvalid') : undefined"
-      :data-testid="`initiative-preset-field-${field.key}`"
+      :error="pathInvalid(field) ? t('common.pathInvalid') : undefined"
+      :data-testid="`${testidPrefix}-${field.key}`"
     >
       <!-- checkbox-group: a vertical list of toggles whose value is the checked option set. -->
       <div v-if="field.type === 'checkbox-group'" class="space-y-1.5">
@@ -116,6 +107,7 @@ function selectItems(field: InitiativePresetField) {
           :key="opt.value"
           :model-value="groupValue(field.key).includes(opt.value)"
           :label="opt.label"
+          :data-testid="`${testidPrefix}-${field.key}-${opt.value}`"
           @update:model-value="
             (v: boolean | 'indeterminate') => toggleGroup(field.key, opt.value, v === true)
           "
@@ -143,6 +135,7 @@ function selectItems(field: InitiativePresetField) {
         :rows="3"
         autoresize
         class="w-full"
+        :maxlength="field.maxLength"
         :placeholder="field.placeholder"
         @update:model-value="(v: string) => set(field.key, v)"
       />
@@ -163,6 +156,7 @@ function selectItems(field: InitiativePresetField) {
         :type="field.type === 'password' ? 'password' : 'text'"
         class="w-full"
         :class="{ 'font-mono': field.type === 'path' }"
+        :maxlength="field.maxLength"
         :placeholder="field.placeholder"
         @update:model-value="(v: string) => set(field.key, v)"
       />

package/app/components/inputGate/InputGateNotice.vue

@@ -4,7 +4,7 @@ import type { InputGateIssue, InputGateIssueCode, RunInputGate } from '@cat-fact
 import type { InputGateTone } from '~/utils/inputGate'
 import { useInputGateStore } from '~/stores/inputGate'
 
-// The PRE-TOKEN INPUT GATE's notice: what the structural check found in the task's authored
+// The PRE-DISPATCH INPUT GATE's notice: what the structural check found in the task's authored
 // input, and the two ways out. Shown wherever a run parked on the gate is surfaced (the
 // inspector's execution panel, the step-detail overlay), so it is a plain component over a
 // verdict rather than an overlay of its own, its remedy is to go and edit the task, which is a

package/app/components/panels/AgentStepDetail.vue

@@ -173,7 +173,7 @@ const dedicatedPark = computed(() =>
   step.value ? dedicatedParkView(step.value, instance.value) : null,
 )
 /**
- * The PRE-TOKEN INPUT GATE's verdict when it is what holds this step. Answered INLINE here
+ * The PRE-DISPATCH INPUT GATE's verdict when it is what holds this step. Answered INLINE here
  * (unlike the other dedicated parks, which redirect to a window): its remedy is to edit the
  * task, so there is no second modal to send anyone to.
  *
@@ -448,7 +448,7 @@ async function copyOutput() {
               <!-- a park a dedicated window owns (fork choice / follow-up triage): the
                    generic approval rail can't resolve it (the server refuses), so point
                    the human at the window that can -->
-              <!-- the pre-token input gate holds this step: answered here, in place -->
+              <!-- the pre-dispatch input gate holds this step: answered here, in place -->
               <InputGateNotice
                 v-if="inputGateVerdict && instance"
                 :gate="inputGateVerdict"

package/app/components/panels/inspector/ServiceTestConfig.vue

@@ -320,7 +320,7 @@ function buildEnvTestError(e: unknown): EnvTestError {
     }
   }
   // The handler resolved but its live connection probe failed. The provider's OWN message is the
-  // actionable part ("Kargo project 'X' was not found"), so wrap it in localized prose rather than
+  // actionable part ("project 'X' was not found"), so wrap it in localized prose rather than
   // replacing it with a generic sentence — and offer the same jump, since the fix is in the
   // handler's connection config.
   if (reason === 'env_test_connection_failed' && parsed?.message) {

package/app/components/panels/inspector/TaskExecution.vue

@@ -61,7 +61,7 @@ const isEmpty = computed(
 // its live "Spinning up…" phase (the shared failure banner renders below).
 const runFailed = computed(() => instance.value?.status === 'failed')
 /**
- * The run's PRE-TOKEN INPUT GATE notice: the park while it holds the run, the waiver once
+ * The run's PRE-DISPATCH INPUT GATE notice: the park while it holds the run, the waiver once
  * somebody overruled it, and the ADVISORY findings a `passed` verdict still carries (which is
  * the entire product of `advisory` mode, and how `standard` mode reports a thin description).
  * Read off the RUN, not a step: the gate guards the first dispatch and leaves nothing
@@ -483,7 +483,7 @@ async function mergePr() {
             </UButton>
             <!-- The generic approve/review rail. Reached only once no dedicated surface owns
                  the park: the branches above took the fork and follow-up windows, so the one
-                 left to exclude is the PRE-TOKEN INPUT GATE, which rides `step.approval` too
+                 left to exclude is the PRE-DISPATCH INPUT GATE, which rides `step.approval` too
                  but is refused by the generic resolver server-side (approving it would mark the
                  run's first working step done and skip the work). It is answered by the notice
                  above the list. Asked of `dedicatedParkView` rather than re-derived here, so

package/app/components/settings/WorkspaceSettingsPanel.vue

@@ -368,7 +368,7 @@ async function save() {
               </div>
             </section>
 
-            <!-- The pre-token input gate: the structural check of a task's own wording, run
+            <!-- The pre-dispatch input gate: the structural check of a task's own wording, run
                  before a run's first agent step is dispatched. -->
             <section class="space-y-2">
               <h3 class="text-sm font-semibold text-slate-200">

package/app/composables/api/inputGate.ts

@@ -2,7 +2,7 @@ import { resolveInputGateContract, type ResolveInputGateChoice } from '@cat-fact
 import type { ApiContext } from './context'
 
 /**
- * The PRE-TOKEN INPUT GATE: a run whose task states nothing an agent could act on parks before
+ * The PRE-DISPATCH INPUT GATE: a run whose task states nothing an agent could act on parks before
  * its first dispatch, having spent no tokens. This resolves that park: `recheck` re-evaluates
  * the task as it now stands (the fix is verified, not asserted), `proceed` waives the findings.
  *

package/app/modular/nav-contributions.spec.ts

@@ -111,7 +111,7 @@ describe('navSlotFilter', () => {
     // Model providers are NOT an integration: the split is what makes the engines findable.
     expect(kept).toContain('model-providers')
     // ...and so does everything the everyday delivery loop runs on, however deep it feels:
-    // authoring a flow, the standards library, and the PREnv/runner plumbing.
+    // authoring a flow, the standards library, and the ephemeral-env/runner plumbing.
     expect(kept).toContain('build-pipeline')
     expect(kept).toContain('fragments')
     // Also the only route to the guided per-service Compose environment setup, which folded

package/app/modular/nav-contributions.ts

@@ -279,7 +279,7 @@ const S = (...s: NavSurface[]) => s as readonly NavSurface[]
  *
  * Everything else stays in basic because the delivery loop needs it: authoring a flow
  * (`build-pipeline`), adding a repo (`add-from-repo`), the standards/skills library
- * (`fragments`), the PREnv + runner plumbing (`infrastructure`, which is also the only route
+ * (`fragments`), the ephemeral-env + runner plumbing (`infrastructure`, which is also the only route
  * to the guided per-service Compose environment setup), and the workspace/model configuration
  * a run actually reads (`workspace-settings`, `model-config`).
  */

package/app/stores/inputGate.ts

@@ -6,7 +6,7 @@ import { useWorkspaceStore } from '~/stores/workspace'
 import { useExecutionStore } from '~/stores/execution'
 
 /**
- * The PRE-TOKEN INPUT GATE's action surface. The verdict itself lives on the run
+ * The PRE-DISPATCH INPUT GATE's action surface. The verdict itself lives on the run
  * (`instance.inputGate`) and is kept fresh by the execution stream, so this store only wraps the
  * `resolve` action, tracks the in-flight state so the notice can disable its buttons, and
  * reflects the returned verdict back so the UI updates before the stream echoes it.

package/app/stores/ui/resultViews.ts

@@ -86,7 +86,7 @@ export function createUiResultViews() {
         : step
           ? (park ?? agentKindMeta(step.agentKind).resultView)
           : undefined
-    // The PRE-TOKEN INPUT GATE is the one dedicated park with no window of its own: it is
+    // The PRE-DISPATCH INPUT GATE is the one dedicated park with no window of its own: it is
     // answered by an inline notice, which the generic step detail renders. Routing to the
     // step's usual result view instead would open a window about work that has not run.
     if (park === 'input-gate') {