@cat-factory/app 0.215.2 → 0.217.1

package/app/utils/descriptorFields.spec.ts

@@ -0,0 +1,126 @@
+import { describe, it, expect } from 'vitest'
+import type { DescriptorField } from '~/types/domain'
+import {
+  defaultDescriptorValues,
+  descriptorGroupValue,
+  setDescriptorCheckbox,
+  setDescriptorValue,
+  toggleDescriptorGroupValue,
+} from './descriptorFields'
+
+const field = (over: Partial<DescriptorField> & Pick<DescriptorField, 'key'>): DescriptorField => ({
+  label: over.key,
+  ...over,
+})
+
+describe('defaultDescriptorValues', () => {
+  it('seeds each declared default in its own contract shape', () => {
+    // The form model is the wire shape, so a default has to arrive typed: the shared validator
+    // refuses a `'3'` where a `number` field is declared, and would refuse it at create time too.
+    expect(
+      defaultDescriptorValues([
+        field({ key: 'style', type: 'select', default: 'collection' }),
+        field({ key: 'depth', type: 'number', default: '3' }),
+        field({ key: 'gate', type: 'checkbox', default: 'true' }),
+        field({ key: 'ops', type: 'checkbox-group', defaultValues: ['create', 'list'] }),
+        field({ key: 'dir', type: 'path', default: 'docs' }),
+      ]),
+    ).toEqual({
+      style: 'collection',
+      depth: 3,
+      gate: true,
+      ops: ['create', 'list'],
+      dir: 'docs',
+    })
+  })
+
+  it('leaves a field with no meaningful default ABSENT rather than blank', () => {
+    // Absent is what validation reads as unset, so seeding `''`/`[]`/`false` would both freeze an
+    // empty answer and (for a required field) look filled to nothing that checks it.
+    expect(
+      defaultDescriptorValues([
+        field({ key: 'entity', type: 'text' }),
+        field({ key: 'notes', type: 'textarea', default: '' }),
+        field({ key: 'gate', type: 'checkbox' }),
+        field({ key: 'gateOff', type: 'checkbox', default: 'false' }),
+        field({ key: 'ops', type: 'checkbox-group', defaultValues: [] }),
+        field({ key: 'depth', type: 'number', default: 'not-a-number' }),
+      ]),
+    ).toEqual({})
+  })
+
+  it('copies a multi-select default, so editing the form cannot mutate the descriptor', () => {
+    const ops = field({ key: 'ops', type: 'checkbox-group', defaultValues: ['create'] })
+    const seeded = defaultDescriptorValues([ops])
+    ;(seeded.ops as string[]).push('delete')
+    expect(ops.defaultValues).toEqual(['create'])
+  })
+})
+
+describe('setDescriptorValue', () => {
+  it('drops a value the shared rules read as unset rather than freezing it', () => {
+    // Absent is what `validateDescriptorFields` treats as unfilled and what
+    // `sanitizeDescriptorFields` refuses to freeze, so the form must not hold one either: a
+    // cleared field that stayed as `''`/`[]`/`false` would reach the wire as a collected answer.
+    expect(setDescriptorValue({ entity: 'Order' }, 'entity', '')).toEqual({})
+    expect(setDescriptorValue({ ops: ['create'] }, 'ops', [])).toEqual({})
+    expect(setDescriptorValue({ gate: true }, 'gate', false)).toEqual({})
+    expect(setDescriptorValue({ entity: 'Order' }, 'entity', undefined)).toEqual({})
+  })
+
+  it('keeps a numeric 0 but drops a half-typed number', () => {
+    // `0` is a real answer. `NaN` is what `Number('')`/a partial entry yields, and it serialises to
+    // `null` on the wire, which the value schema refuses: the submit would fail with a raw schema
+    // error naming nothing the user typed.
+    expect(setDescriptorValue({}, 'depth', 0)).toEqual({ depth: 0 })
+    expect(setDescriptorValue({ depth: 3 }, 'depth', Number.NaN)).toEqual({})
+  })
+
+  it('does not mutate the bag it was given', () => {
+    const before = { entity: 'Order' }
+    expect(setDescriptorValue(before, 'style', 'action')).toEqual({
+      entity: 'Order',
+      style: 'action',
+    })
+    expect(before).toEqual({ entity: 'Order' })
+  })
+})
+
+describe('setDescriptorCheckbox', () => {
+  it('persists an explicit false ONLY for a default-ON toggle', () => {
+    // A default-ON checkbox is the one field where absent and `false` are opposite facts: a
+    // consumer reads the opt-out as `inputs[key] !== false` (the tech-migration preset's
+    // `humanReview`), so dropping the `false` would make the toggle dead.
+    const onByDefault = field({ key: 'humanReview', type: 'checkbox', default: 'true' })
+    expect(setDescriptorCheckbox({}, onByDefault, false)).toEqual({ humanReview: false })
+    expect(setDescriptorCheckbox({}, onByDefault, true)).toEqual({ humanReview: true })
+    // A default-OFF checkbox never freezes a redundant `false`: absent already means unchecked.
+    const offByDefault = field({ key: 'breaking', type: 'checkbox' })
+    expect(setDescriptorCheckbox({ breaking: true }, offByDefault, false)).toEqual({})
+  })
+})
+
+describe('toggleDescriptorGroupValue', () => {
+  it('adds, removes and de-duplicates without freezing an empty selection', () => {
+    expect(toggleDescriptorGroupValue({}, 'ops', 'create', true)).toEqual({ ops: ['create'] })
+    expect(toggleDescriptorGroupValue({ ops: ['create'] }, 'ops', 'create', true)).toEqual({
+      ops: ['create'],
+    })
+    expect(toggleDescriptorGroupValue({ ops: ['create', 'list'] }, 'ops', 'create', false)).toEqual(
+      {
+        ops: ['list'],
+      },
+    )
+    // Unchecking the last option leaves the key ABSENT, not an empty array.
+    expect(toggleDescriptorGroupValue({ ops: ['create'] }, 'ops', 'create', false)).toEqual({})
+  })
+
+  it('reads a wrong-shaped stored value as an empty selection', () => {
+    // A bag can arrive from a probe prefill or a since-changed descriptor, so the reader narrows
+    // rather than assuming: a scalar under a multi-select key must not throw in the renderer.
+    expect(descriptorGroupValue({ ops: 'create' }, 'ops')).toEqual([])
+    expect(toggleDescriptorGroupValue({ ops: 'create' }, 'ops', 'list', true)).toEqual({
+      ops: ['list'],
+    })
+  })
+})

package/app/utils/descriptorFields.ts

@@ -0,0 +1,104 @@
+import type { DescriptorField, DescriptorFieldValue, DescriptorFieldValues } from '~/types/domain'
+
+// Form-side helpers over the shared descriptor-field vocabulary (`contracts/src/form-fields.ts`),
+// used by every surface that renders one through `DescriptorFields.vue`: an initiative preset's
+// create form and a reusable operation's per-case form on a custom task type.
+//
+// The RULES (visibility, validation, sanitization, prose rendering) live in contracts, because the
+// server has to agree about them. What lives here is what only a FORM decides: which values to
+// start it with, and how one edit changes the bag. Both are pure functions over the value bag
+// rather than methods inside the SFC, so the mutation rules a wrong answer would freeze on an
+// entity are unit-testable without mounting a component.
+
+/**
+ * The initial, typed values a field list implies: its declared DEFAULTS folded into the
+ * `DescriptorFieldValues` shape the renderer and the wire contract expect (`checkbox-group` to
+ * `string[]`, `checkbox` to a boolean, `number` to a number, everything else a string). Only fields
+ * with a meaningful default are seeded, so an unfilled optional field stays absent (which is what
+ * validation reads as unset) and never freezes an empty value. A repo-detection probe's prefill and
+ * the user's own edits layer on top.
+ */
+export function defaultDescriptorValues(fields: readonly DescriptorField[]): DescriptorFieldValues {
+  const values: DescriptorFieldValues = {}
+  for (const field of fields) {
+    if (field.type === 'checkbox-group') {
+      if (field.defaultValues?.length) values[field.key] = [...field.defaultValues]
+    } else if (field.type === 'checkbox') {
+      if (field.default === 'true') values[field.key] = true
+    } else if (field.type === 'number') {
+      const parsed = Number(field.default)
+      if (field.default !== undefined && field.default !== '' && Number.isFinite(parsed)) {
+        values[field.key] = parsed
+      }
+    } else if (field.default) {
+      values[field.key] = field.default
+    }
+  }
+  return values
+}
+
+/**
+ * A value that must stay ABSENT from the bag rather than freeze on the entity: an unchecked
+ * (`false`) checkbox, a blank string, an empty multi-select, or a number that is not one (a
+ * half-typed `number` input reads as `NaN`, which serialises to `null` on the wire and is refused
+ * by the value schema, so the form must never carry it). A numeric `0` is a real answer and is kept.
+ *
+ * The same judgement the shared `validateDescriptorFields` / `sanitizeDescriptorFields` make about
+ * an unset value, applied at the moment of the edit so the model never holds one at all.
+ */
+function isEmptyDescriptorValue(value: DescriptorFieldValue): boolean {
+  if (typeof value === 'number') return !Number.isFinite(value)
+  return value === false || value === '' || (Array.isArray(value) && value.length === 0)
+}
+
+/**
+ * One field's value set immutably on the bag, DROPPING an empty one so a cleared field never
+ * freezes an empty `''`/`[]`/`false` (mirroring `ProviderConnectionTab`'s delete-when-blank).
+ */
+export function setDescriptorValue(
+  values: DescriptorFieldValues,
+  key: string,
+  value: DescriptorFieldValue | undefined,
+): DescriptorFieldValues {
+  const next = { ...values }
+  if (value === undefined || isEmptyDescriptorValue(value)) delete next[key]
+  else next[key] = value
+  return next
+}
+
+/**
+ * A checkbox's value set on the bag. A checkbox whose descriptor default is ON (`default: 'true'`)
+ * must be able to persist an explicit `false`: {@link setDescriptorValue} otherwise drops it (an off
+ * box "stays unset"), which for a default-ON field is indistinguishable from "untouched, still on",
+ * so a consumer reading the opt-out as `humanReview !== false` (`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`.
+ */
+export function setDescriptorCheckbox(
+  values: DescriptorFieldValues,
+  field: DescriptorField,
+  checked: boolean,
+): DescriptorFieldValues {
+  if (!checked && field.default === 'true') return { ...values, [field.key]: false }
+  return setDescriptorValue(values, field.key, checked)
+}
+
+/** One `checkbox-group` field's current value, as the `string[]` the renderer and wire expect. */
+export function descriptorGroupValue(values: DescriptorFieldValues, key: string): string[] {
+  const value = values[key]
+  return Array.isArray(value) ? value : []
+}
+
+/** One option toggled on/off in a `checkbox-group` field's value (deduped, order-preserving). */
+export function toggleDescriptorGroupValue(
+  values: DescriptorFieldValues,
+  key: string,
+  option: string,
+  checked: boolean,
+): DescriptorFieldValues {
+  const current = descriptorGroupValue(values, key)
+  const next = checked
+    ? [...new Set([...current, option])]
+    : current.filter((entry) => entry !== option)
+  return setDescriptorValue(values, key, next)
+}

package/app/utils/initiative.ts

@@ -4,8 +4,6 @@ import type {
   InitiativeItem,
   InitiativeItemStatus,
   InitiativePhase,
-  InitiativePresetDescriptor,
-  InitiativePresetInputs,
   InitiativeQa,
   InitiativeStatus,
 } from '~/types/domain'
@@ -140,34 +138,6 @@ export const INITIATIVE_FOLLOWUP_STATUS_CHIPS: Record<InitiativeFollowUp['status
   dismissed: 'neutral',
 }
 
-/**
- * The initial, typed create-form values a preset descriptor implies — its field DEFAULTS folded
- * into the `InitiativePresetInputs` shape the renderer + wire contract expect (`checkbox-group` →
- * `string[]`, `checkbox` → boolean, `number` → number, everything else a string). Only fields with
- * a meaningful default are seeded, so unfilled optional fields stay absent (equivalent to unset for
- * validation) and never freeze an empty value. The probe prefill and the user's edits layer on top.
- */
-export function defaultPresetInputs(
-  descriptor: InitiativePresetDescriptor,
-): InitiativePresetInputs {
-  const inputs: InitiativePresetInputs = {}
-  for (const field of descriptor.fields) {
-    if (field.type === 'checkbox-group') {
-      if (field.defaultValues?.length) inputs[field.key] = [...field.defaultValues]
-    } else if (field.type === 'checkbox') {
-      if (field.default === 'true') inputs[field.key] = true
-    } else if (field.type === 'number') {
-      const parsed = Number(field.default)
-      if (field.default !== undefined && field.default !== '' && Number.isFinite(parsed)) {
-        inputs[field.key] = parsed
-      }
-    } else if (field.default) {
-      inputs[field.key] = field.default
-    }
-  }
-  return inputs
-}
-
 /** Completion rollup across an initiative's items, or null when there are none. */
 export function initiativeProgress(
   items: InitiativeItem[] | undefined,

package/app/utils/inputGate.spec.ts

@@ -0,0 +1,52 @@
+import { describe, expect, it } from 'vitest'
+import type { RunInputGate } from '@cat-factory/contracts'
+import type { ExecutionInstance } from '~/types/execution'
+import { inputGateNoticeFor } from './inputGate'
+
+const run = (inputGate?: Partial<RunInputGate>): ExecutionInstance =>
+  ({
+    id: 'exe_1',
+    steps: [],
+    ...(inputGate
+      ? { inputGate: { mode: 'standard', issues: [], checkedAt: 1, ...inputGate } }
+      : {}),
+  }) as unknown as ExecutionInstance
+
+const thin = [{ code: 'description_thin', severity: 'advisory' }] as RunInputGate['issues']
+const missing = [{ code: 'description_missing', severity: 'blocking' }] as RunInputGate['issues']
+
+describe('inputGateNoticeFor', () => {
+  it('shows the park, with the tone that carries the two ways out', () => {
+    expect(inputGateNoticeFor(run({ status: 'blocked', issues: missing }))?.tone).toBe('blocked')
+  })
+
+  it('keeps a waiver visible, because what was overruled explains the output', () => {
+    expect(inputGateNoticeFor(run({ status: 'overridden', issues: missing }))?.tone).toBe('waived')
+  })
+
+  // The regression this pins: advisory findings were recorded on the run and reported over the
+  // API while being invisible in the product, which left `advisory` MODE (whose entire purpose is
+  // "watch what the gate would have caught before turning it up") with nothing to watch.
+  it('shows advisory findings on a PASSED verdict, which is what advisory mode produces', () => {
+    const notice = inputGateNoticeFor(run({ status: 'passed', mode: 'advisory', issues: thin }))
+    expect(notice?.tone).toBe('advisory')
+    expect(notice?.gate.issues).toEqual(thin)
+  })
+
+  it('shows a standard-mode advisory too, which never parks but is still a finding', () => {
+    expect(inputGateNoticeFor(run({ status: 'passed', issues: thin }))?.tone).toBe('advisory')
+  })
+
+  it.each(['passed', 'off', 'not_applicable'] as const)(
+    'says nothing about a %s verdict with no findings',
+    (status) => {
+      expect(inputGateNoticeFor(run({ status, issues: [] }))).toBeNull()
+    },
+  )
+
+  it('says nothing when the gate has not evaluated the run yet, or there is no run', () => {
+    expect(inputGateNoticeFor(run())).toBeNull()
+    expect(inputGateNoticeFor(null)).toBeNull()
+    expect(inputGateNoticeFor(undefined)).toBeNull()
+  })
+})

package/app/utils/inputGate.ts

@@ -0,0 +1,44 @@
+// Which PRE-DISPATCH INPUT GATE verdicts a run surfaces, and how they are presented.
+//
+// The gate records a verdict for EVERY disposition, including the ones where it did nothing, so
+// "has a verdict" is not the same question as "has something to tell a human". This is the one
+// place that answers the second one, because the run panel and the step-detail overlay both ask
+// it and a per-component `status === 'blocked'` check is how they drift.
+
+import type { ExecutionInstance } from '~/types/execution'
+import type { RunInputGate } from '@cat-factory/contracts'
+
+/**
+ * How a verdict reads to a human:
+ *
+ *  - `blocked`: the run is parked, and the notice carries the two ways out.
+ *  - `waived`: somebody read the blocking findings and ran anyway. Kept visible on the run that
+ *    carries it, because what was overruled is part of what explains the output.
+ *  - `advisory`: findings were recorded and nothing was parked. This is the whole point of
+ *    `advisory` MODE ("watch what the gate would have caught before turning it up"), and it is
+ *    also how `standard` mode reports a short description or a spike with no success criteria.
+ */
+export type InputGateTone = 'blocked' | 'waived' | 'advisory'
+
+/**
+ * The verdict a run should show, with the tone to show it in, or `null` when the gate has
+ * nothing to say.
+ *
+ * Nothing to say covers three real and different facts that happen to share a presentation:
+ * a verdict that has not been stamped yet, one the workspace turned `off`, and a clean `passed`.
+ * None of them is a message, so none of them earns a box on the panel. The distinction between
+ * them is preserved on the run and read by the API, not painted over here.
+ *
+ * Note what this deliberately does NOT gate on: a `passed` status. A `passed` verdict carrying
+ * advisories is exactly what advisory mode produces, and keying the notice off the status alone
+ * left every advisory finding recorded, reported over the API, and invisible in the product.
+ */
+export function inputGateNoticeFor(
+  instance: ExecutionInstance | null | undefined,
+): { gate: RunInputGate; tone: InputGateTone } | null {
+  const gate = instance?.inputGate
+  if (!gate) return null
+  if (gate.status === 'blocked') return { gate, tone: 'blocked' }
+  if (gate.status === 'overridden') return { gate, tone: 'waived' }
+  return gate.issues.length > 0 ? { gate, tone: 'advisory' } : null
+}

package/app/utils/pipelineRender.spec.ts

@@ -1,5 +1,5 @@
 import { describe, it, expect } from 'vitest'
-import type { PipelineStep } from '~/types/execution'
+import type { ExecutionInstance, PipelineStep } from '~/types/execution'
 import { dedicatedParkView } from './pipelineRender'
 
 /** A minimal coder step; the predicate only reads approval/followUps/forkDecision. */
@@ -11,6 +11,14 @@ const step = (over: Partial<PipelineStep>): PipelineStep =>
     ...over,
   }) as PipelineStep
 
+/**
+ * A run carrying no input-gate verdict: the ordinary case for every step-shaped park below.
+ * Passed explicitly because `dedicatedParkView` REQUIRES the run — the gate's park is a fact
+ * about the run rather than the step, so a call that omitted it would silently miss it.
+ */
+const run = (over: Partial<ExecutionInstance> = {}): ExecutionInstance =>
+  ({ id: 'exe_1', steps: [], ...over }) as unknown as ExecutionInstance
+
 const followUps = (statuses: string[]) => ({
   enabled: true,
   items: statuses.map((status, i) => ({
@@ -32,13 +40,13 @@ describe('dedicatedParkView', () => {
   // proceed" rail.
   it('owns a follow-up park (pending approval + undecided items)', () => {
     expect(
-      dedicatedParkView(step({ followUps: followUps(['pending', 'answered']) as never })),
+      dedicatedParkView(step({ followUps: followUps(['pending', 'answered']) as never }), run()),
     ).toBe('follow-ups')
   })
 
   it('does not claim a step whose follow-up items are all decided', () => {
     expect(
-      dedicatedParkView(step({ followUps: followUps(['answered', 'dismissed']) as never })),
+      dedicatedParkView(step({ followUps: followUps(['answered', 'dismissed']) as never }), run()),
     ).toBeNull()
   })
 
@@ -47,26 +55,56 @@ describe('dedicatedParkView', () => {
     expect(
       dedicatedParkView(
         step({ state: 'working', approval: null, followUps: followUps(['pending']) as never }),
+        run(),
       ),
     ).toBeNull()
   })
 
   it('owns the fork park while awaiting a choice, and while a chat reply is in flight', () => {
-    expect(dedicatedParkView(step({ forkDecision: { status: 'awaiting_choice' } as never }))).toBe(
-      'fork-decision',
-    )
-    expect(dedicatedParkView(step({ forkDecision: { status: 'answering' } as never }))).toBe(
+    expect(
+      dedicatedParkView(step({ forkDecision: { status: 'awaiting_choice' } as never }), run()),
+    ).toBe('fork-decision')
+    expect(dedicatedParkView(step({ forkDecision: { status: 'answering' } as never }), run())).toBe(
       'fork-decision',
     )
   })
 
   it('releases the step once the fork is resolved (chosen / single_path / skipped)', () => {
     for (const status of ['chosen', 'single_path', 'skipped', 'proposing']) {
-      expect(dedicatedParkView(step({ forkDecision: { status } as never }))).toBeNull()
+      expect(dedicatedParkView(step({ forkDecision: { status } as never }), run())).toBeNull()
     }
   })
 
   it('leaves a plain approval park to the generic rail', () => {
-    expect(dedicatedParkView(step({}))).toBeNull()
+    expect(dedicatedParkView(step({}), run())).toBeNull()
+  })
+
+  // The PRE-DISPATCH INPUT GATE parks whatever step 0 happens to be and leaves nothing
+  // kind-specific on the step, so it is recognised off the RUN. The generic approve resolver
+  // refuses it server-side: approving it would mark the run's first working step done and skip
+  // the work the run exists to do.
+  it('owns a step whose park is the input gate, read off the run', () => {
+    const blocked = run({
+      inputGate: { status: 'blocked', mode: 'standard', issues: [], checkedAt: 1 },
+    } as never)
+    expect(dedicatedParkView(step({}), blocked)).toBe('input-gate')
+  })
+
+  it('releases the step once the gate is waived or passed', () => {
+    for (const status of ['overridden', 'passed', 'off', 'not_applicable']) {
+      const settled = run({
+        inputGate: { status, mode: 'standard', issues: [], checkedAt: 1 },
+      } as never)
+      expect(dedicatedParkView(step({}), settled)).toBeNull()
+    }
+  })
+
+  it('does not claim a step with no pending approval, whatever the gate says', () => {
+    // The gate's verdict alone must not turn an unparked step into a dedicated park: a run
+    // parked on the gate has exactly one step holding the approval.
+    const blocked = run({
+      inputGate: { status: 'blocked', mode: 'standard', issues: [], checkedAt: 1 },
+    } as never)
+    expect(dedicatedParkView(step({ approval: null, state: 'working' }), blocked)).toBeNull()
   })
 })

package/app/utils/pipelineRender.ts

@@ -2,7 +2,7 @@
 // TaskPipelineMini, AgentStepDetail), so the "is this step still live?" logic stays
 // in one place rather than being re-derived as inline ternaries per component.
 
-import type { AgentState, PipelineStep } from '~/types/execution'
+import type { AgentState, ExecutionInstance, PipelineStep } from '~/types/execution'
 
 /**
  * Visual state of a conditionally-run companion attached to a gate step (today the
@@ -141,8 +141,29 @@ export function isCompanionKind(kind: string): boolean {
  * server-side (`assertNotIterativeGate`), so every surface that offers a step's pending
  * approval must route these to their window instead of the generic "Approve & proceed"
  * rail — which would blink a 409 and resolve nothing.
+ *
+ * `input-gate` is the odd one out: it is resolved by an inline NOTICE rather than an overlay,
+ * because its remedy is to go and edit the task, which is a board action rather than something
+ * a modal could hold.
  */
-export function dedicatedParkView(step: PipelineStep): 'follow-ups' | 'fork-decision' | null {
+export function dedicatedParkView(
+  step: PipelineStep,
+  instance: ExecutionInstance | null | undefined,
+): 'follow-ups' | 'fork-decision' | 'input-gate' | null {
+  // The PRE-DISPATCH INPUT GATE parks whatever step 0 happens to be, so it leaves nothing on the
+  // STEP to recognise it by: its verdict is a fact about the RUN. Checked first, and off the
+  // instance: approving it generically would mark the run's first working step done and skip
+  // the work the run exists to do.
+  //
+  // `instance` is REQUIRED, and nullable rather than optional on purpose. Every park surface has
+  // the run in hand, and an optional parameter is how one of them silently stops passing it: the
+  // function would go on returning `null` for a gate-parked step, which each caller reads as
+  // "the generic approve rail applies" — the exact 409-blinking rail this exists to prevent.
+  // It still ACCEPTS an absent run (a store lookup that has not resolved), because that is a real
+  // state a caller has to be able to express; what it does not accept is not being asked.
+  if (instance?.inputGate?.status === 'blocked' && step.approval?.status === 'pending') {
+    return 'input-gate'
+  }
   // The fork park sits BEFORE the coder's build dispatch; `answering` (a chat turn in
   // flight) still belongs to the fork window, which renders the pending reply.
   const fork = step.forkDecision?.status

package/i18n/locales/de.json

@@ -949,6 +949,16 @@
         "saveFailed": "Einstellungen konnten nicht gespeichert werden",
         "budgetSaved": "Budget gespeichert",
         "budgetSaveFailed": "Budget konnte nicht gespeichert werden"
+      },
+      "inputGate": {
+        "heading": "Eingabeprüfung vor dem Start eines Laufs",
+        "body": "Prüft den Wortlaut einer Aufgabe, bevor der erste Agentenschritt startet, damit eine unbearbeitbare Aufgabe ohne Verbrauch stoppt. Standard hält den Lauf an bei leerer oder Platzhalter-Beschreibung, einem Fehler ohne Reproduktionskontext oder einer Review-Aufgabe ohne Pull Request.",
+        "mode": "Modus",
+        "modes": {
+          "standard": "Standard (bei blockierender Lücke anhalten)",
+          "advisory": "Hinweis (erfassen, nie anhalten)",
+          "off": "Aus (Prüfung überspringen)"
+        }
       }
     },
     "localModelEndpoints": {
@@ -2661,6 +2671,7 @@
       "continue": "Weiter",
       "submit": "Aufgabe hinzufügen",
       "addFailedTitle": "Aufgabe konnte nicht hinzugefügt werden",
+      "customFieldsInvalid": "Das Formular dieses Aufgabentyps hat sich seit dem Öffnen geändert, daher passen die Antworten nicht mehr zu den Angaben, die es verlangt. Schließen Sie den Dialog und öffnen Sie ihn erneut, um die aktuellen Felder auszufüllen.",
       "linkFailed": "Aufgabe hinzugefügt, aber {count} Anhang konnte nicht verknüpft werden | Aufgabe hinzugefügt, aber {count} Anhänge konnten nicht verknüpft werden",
       "review": {
         "prUrl": "Pull Request",
@@ -4804,7 +4815,6 @@
       "titlePlaceholder": "z. B. Die API auf das neue Auth-Modell migrieren",
       "goalField": "Ziel",
       "goalPlaceholder": "Beschreiben Sie das Ziel, die Einschränkungen und den groben Umfang. Der Planer verfeinert dies zu einem mehrphasigen Plan.",
-      "pathInvalid": "Geben Sie einen Pfad innerhalb des Repositorys an (kein \"..\", keine absoluten Pfade und keine Backslashes).",
       "hint": "Es läuft noch nichts: Führen Sie nach dem Erstellen die Initiative-Planning-Pipeline auf dem Block aus. Sie analysiert die Codebasis und entwirft den mehrphasigen Plan zu Ihrer Freigabe.",
       "submit": "Initiative erstellen",
       "failedTitle": "Die Initiative konnte nicht erstellt werden",
@@ -5017,7 +5027,8 @@
       "confirm": "Verwerfen",
       "keep": "Weiter bearbeiten"
     },
-    "edit": "Bearbeiten"
+    "edit": "Bearbeiten",
+    "pathInvalid": "Geben Sie einen Pfad innerhalb des Repositorys an (kein \"..\", keine absoluten Pfade und keine Backslashes)."
   },
   "access": {
     "noBoardWrite": "Nur-Lese-Zugriff: Sie können dieses Board ansehen, aber nicht bearbeiten.",
@@ -5142,6 +5153,8 @@
         "binary_output_service_invalid": "Dienst für Binärausgaben nicht auflösbar",
         "binary_output_generator_invalid": "Generator für Binärausgaben nicht auflösbar",
         "foundational_service_not_inherited": "Dieses Board hat den Dienst registriert",
+        "input_gate_not_parked": "Nichts zu beantworten",
+        "input_gate_parked": "Über die Eingabeprüfung der Aufgabe beantworten",
         "ticket_already_linked": "Dieses Ticket hat bereits eine Aufgabe",
         "dry_run_not_mergeable": "Probelauf kann nicht zusammengeführt werden"
       },
@@ -5176,6 +5189,8 @@
         "binary_output_service_invalid": "Ein Schritt, der Binärausgaben erzeugt, wählt einen Basisdienst aus, den der Katalog dieses Workspace nicht auflösen kann: Die ID ist unbekannt, oder der gewählte Speicherdienst trägt nicht die Fähigkeit asset-storage. Korrigieren Sie die Auswahl des Schritts oder registrieren Sie den Dienst und starten Sie erneut.",
         "binary_output_generator_invalid": "Ein Schritt, der Binärausgaben erzeugt, wählt eine generative Integration aus, die diese Installation nicht registriert, oder keine der gewählten Integrationen erzeugt einen Inhaltstyp, den der Schritt liefern muss. Generative Integrationen werden im Code der Installation registriert, nicht in diesem Workspace: registrieren Sie sie oder korrigieren Sie die Auswahl des Schritts und starten Sie erneut.",
         "foundational_service_not_inherited": "Abwählen gilt für einen vom Konto geerbten Dienst. Diese ID ist von diesem Board registriert, es gibt also nichts abzuwählen - lösche stattdessen den eigenen Eintrag des Boards.",
+        "input_gate_not_parked": "Dieser Lauf wartet nicht mehr auf seine Eingabeprüfung. Möglicherweise hat sie jemand schon beantwortet oder der Lauf ist weitergelaufen.",
+        "input_gate_parked": "Dieser Lauf wartet auf seine Eingabeprüfung, die über die Freigabe nicht beantwortet werden kann. Nutzen Sie den Hinweis am Lauf: Aufgabe ergänzen und erneut prüfen, oder trotzdem ausführen.",
         "ticket_already_linked": "Ein Ticket kann nur eine Aufgabe stützen. Es erneut zu verknüpfen würde der bestehenden Aufgabe genau den Kontext entziehen, mit dem sie angelegt wurde. Öffne stattdessen diese Aufgabe oder hebe die Verknüpfung des Tickets zuerst auf.",
         "dry_run_not_mergeable": "Dieser Pull Request stammt aus einem Probelauf und kann hier nicht zusammengeführt werden. Starte die Aufgabe erneut als echten Lauf, um einen Pull Request zu erzeugen, den dieser Arbeitsbereich zusammenführt."
       },
@@ -5414,6 +5429,51 @@
       "fail": "Lauf fehlgeschlagen"
     }
   },
+  "inputGate": {
+    "blockedTitle": "Diese Aufgabe braucht mehr Details, bevor sie laufen kann",
+    "blockedBody": "Der Lauf wurde vor dem ersten Agentenschritt gestoppt, es wurde also nichts verbraucht. Ergänze das Fehlende an der Aufgabe und prüfe erneut.",
+    "waivedTitle": "Trotz unvollständiger Aufgabe gestartet",
+    "waivedBody": "Jemand hat entschieden, diese Aufgabe mit den unten offenen Lücken auszuführen. Sie bleiben als Teil der Laufhistorie erhalten.",
+    "advisoryTitle": "Einige Lücken wurden notiert, der Lauf lief weiter",
+    "advisoryBody": "Die Eingabeprüfung der Aufgabe hat diese Punkte beim Start gefunden. Keiner davon stoppt die Arbeit, daher wurde nichts angehalten. Wer sie ergänzt, erleichtert den nächsten Lauf.",
+    "severity": {
+      "blocking": "Blockierend",
+      "advisory": "Hinweis"
+    },
+    "recheck": "Aufgabe erneut prüfen",
+    "proceed": "Trotzdem ausführen",
+    "recheckHint": "Die erneute Prüfung liest die Aufgabe im aktuellen Stand, bearbeite sie also zuerst.",
+    "issue": {
+      "description_missing": {
+        "title": "Keine Beschreibung",
+        "hint": "Der Titel benennt die Aufgabe, die Beschreibung ist die Arbeitsgrundlage des Agenten. Schreibe, was sich ändern soll und warum."
+      },
+      "description_placeholder": {
+        "title": "Platzhalter-Beschreibung",
+        "hint": "Die Beschreibung ist ein Platzhalter (\"TBD\", \"n/a\", \"fix it\") statt einer Beschreibung der Arbeit."
+      },
+      "description_thin": {
+        "title": "Sehr kurze Beschreibung",
+        "hint": "Wenige Worte legen selten fest, was \"fertig\" heißt. Mehr Details hier sparen später eine Rückfragerunde."
+      },
+      "reproduction_missing": {
+        "title": "Kein Reproduktionskontext",
+        "hint": "Ein Fehler ohne Schritte, ohne Soll-Ist-Vergleich und ohne Stacktrace lässt den Behebenden nicht erkennen, wann er behoben ist."
+      },
+      "review_target_missing": {
+        "title": "Kein Pull Request zum Prüfen",
+        "hint": "Eine Review-Aufgabe braucht die Nummer oder URL des Pull Requests, den sie lesen soll."
+      },
+      "success_criteria_missing": {
+        "title": "Keine Erfolgskriterien",
+        "hint": "Nenne die Frage, die der Spike beantwortet, oder wie ein gutes Ergebnis aussieht, damit die Zeitbox ein Ziel hat."
+      },
+      "unknown": {
+        "title": "Unbekannter Befund",
+        "hint": "Dieser Lauf hat eine Prüfung erfasst, die diese Version nicht mehr kennt. Sieh die Aufgabe von Hand durch, bevor du fortfährst."
+      }
+    }
+  },
   "consensus": {
     "titlePrefix": "Konsens",
     "participantCount": "keine Teilnehmer | ein Teilnehmer | {count} Teilnehmer",