@cat-factory/app 0.215.2 → 0.216.0

package/app/stores/ui/resultViews.ts

@@ -78,13 +78,21 @@ export function createUiResultViews() {
     // Likewise a coder parked on the implementation-fork choice or on undecided follow-up
     // items: those parks ride `step.approval` too, but the generic approve resolver refuses
     // them server-side, so the step must open the window that CAN resolve it.
+    const park = step ? dedicatedParkView(step, instance) : null
     const view = step?.consensus?.enabled
       ? 'consensus-session'
       : step?.prReview
         ? 'pr-review'
         : step
-          ? (dedicatedParkView(step) ?? agentKindMeta(step.agentKind).resultView)
+          ? (park ?? agentKindMeta(step.agentKind).resultView)
           : undefined
+    // The PRE-TOKEN 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') {
+      stepDetail.value = { instanceId, stepIndex }
+      return
+    }
     if (view && instance) {
       // The brainstorm window is shared by both stages; carry which one from the step's kind.
       const stage =

package/app/stores/workspaceSettings.ts

@@ -14,6 +14,7 @@ const DEFAULTS: WorkspaceSettings = {
   artifactRetentionDays: 14,
   kaizenEnabled: true,
   delegateAgentsToRunnerPool: false,
+  inputGateMode: 'standard',
   reviewFrictionMode: 'off',
   reviewFrictionWarnCount: 3,
   reviewFrictionBlockCount: null,

package/app/types/domain.ts

@@ -80,6 +80,7 @@ export type {
   WorkspaceAccess,
   WorkspaceMember,
   TaskLimitMode,
+  InputGateMode,
   ReviewFrictionMode,
   WorkspaceSettings,
   WorkspaceMetadata,

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-TOKEN 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-TOKEN 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-TOKEN 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": {
@@ -5142,6 +5152,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 +5188,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 +5428,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",

package/i18n/locales/en.json

@@ -623,6 +623,8 @@
         "binary_output_service_invalid": "Binary output service can't be resolved",
         "binary_output_generator_invalid": "Binary output generator can't be resolved",
         "foundational_service_not_inherited": "This board registered that service",
+        "input_gate_not_parked": "Nothing to answer",
+        "input_gate_parked": "Answer it in the task's input check",
         "ticket_already_linked": "This issue already has a task",
         "dry_run_not_mergeable": "Dry run cannot be merged"
       },
@@ -660,6 +662,8 @@
         "binary_output_service_invalid": "A step that generates binary outputs selects a foundational service this workspace's catalog can't resolve: the id is unknown, or the chosen storage service doesn't carry the asset-storage capability. Fix the step's selection or register the service, then start again.",
         "binary_output_generator_invalid": "A step that generates binary outputs selects a generative integration this deployment doesn't register, or none of the selected integrations produces a content type the step must deliver. Generative integrations are registered in the deployment's code, not in this workspace: register it or fix the step's selection, then start again.",
         "foundational_service_not_inherited": "Opting out applies to a service inherited from the account. This id is registered by this board, so there is nothing to opt out of - delete the board's own entry instead.",
+        "input_gate_not_parked": "This run is not waiting on its input check any more. Someone may have answered it already, or the run has moved on.",
+        "input_gate_parked": "This run is parked on its input check, which the approval rail cannot answer. Use the notice on the run: fix the task and re-check, or run it anyway.",
         "ticket_already_linked": "An issue can back only one task, so linking it again would strip the existing task of the context it was created with. Open that task instead, or unlink the issue first.",
         "dry_run_not_mergeable": "This pull request came from a dry run, so it can't be merged from here. Start the task again as a live run to produce a pull request this workspace will merge."
       },
@@ -3398,6 +3402,16 @@
         "saveFailed": "Could not save settings",
         "budgetSaved": "Budget saved",
         "budgetSaveFailed": "Could not save budget"
+      },
+      "inputGate": {
+        "heading": "Input check before a run starts",
+        "body": "Check a task's own wording before the first agent step is dispatched, so a task nobody could act on stops without spending anything. Standard parks the run on an empty or placeholder description, a bug with no reproduction context, or a review task naming no pull request.",
+        "mode": "Mode",
+        "modes": {
+          "standard": "Standard (park on a blocking gap)",
+          "advisory": "Advisory (record, never park)",
+          "off": "Off (skip the check)"
+        }
       }
     },
     "localModelEndpoints": {
@@ -4748,6 +4762,51 @@
       "fail": "Failed the run"
     }
   },
+  "inputGate": {
+    "blockedTitle": "This task needs more detail before it can run",
+    "blockedBody": "The run stopped before its first agent step, so nothing has been spent. Fill in what is missing on the task, then re-check.",
+    "waivedTitle": "Started despite an incomplete task",
+    "waivedBody": "Someone chose to run this task with the gaps below still open. They are kept here as part of the run's record.",
+    "advisoryTitle": "Some gaps were noted, and the run continued",
+    "advisoryBody": "The task's input check found these while starting the run. None of them stops the work, so nothing was parked; filling them in makes the next run easier to get right.",
+    "severity": {
+      "blocking": "Blocking",
+      "advisory": "Advisory"
+    },
+    "recheck": "Re-check the task",
+    "proceed": "Run anyway",
+    "recheckHint": "Re-check reads the task as it stands now, so edit it first.",
+    "issue": {
+      "description_missing": {
+        "title": "No description",
+        "hint": "The title names the task; the description is what an agent works from. Say what should change and why."
+      },
+      "description_placeholder": {
+        "title": "Placeholder description",
+        "hint": "The description is a stand-in (\"TBD\", \"n/a\", \"fix it\") rather than a statement of the work."
+      },
+      "description_thin": {
+        "title": "Very short description",
+        "hint": "A few words rarely pin down what \"done\" means. More detail here saves a round of questions later."
+      },
+      "reproduction_missing": {
+        "title": "No reproduction context",
+        "hint": "A bug with no steps, no observed-versus-expected and no stack trace gives its fixer no way to tell when it is fixed."
+      },
+      "review_target_missing": {
+        "title": "No pull request to review",
+        "hint": "A review task needs the number or URL of the pull request it should read."
+      },
+      "success_criteria_missing": {
+        "title": "No success criteria",
+        "hint": "State the question the spike answers, or what a good outcome looks like, so the timebox has a target."
+      },
+      "unknown": {
+        "title": "Unrecognised finding",
+        "hint": "This run recorded a check this version no longer knows about. Review the task by hand before continuing."
+      }
+    }
+  },
   "requirements": {
     "title": "Requirements review",
     "iteration": "Iteration {current} / {max}",

package/i18n/locales/es.json

@@ -566,6 +566,8 @@
         "binary_output_service_invalid": "No se puede resolver el servicio de salidas binarias",
         "binary_output_generator_invalid": "No se puede resolver el generador de salidas binarias",
         "foundational_service_not_inherited": "Este tablero registró ese servicio",
+        "input_gate_not_parked": "Nada que responder",
+        "input_gate_parked": "Respóndelo en la comprobación de entrada de la tarea",
         "ticket_already_linked": "Esta incidencia ya tiene una tarea",
         "dry_run_not_mergeable": "Una ejecución de prueba no se puede fusionar"
       },
@@ -600,6 +602,8 @@
         "binary_output_service_invalid": "Un paso que genera salidas binarias selecciona un servicio fundacional que el catálogo de este espacio de trabajo no puede resolver: el identificador es desconocido, o el servicio de almacenamiento elegido no tiene la capacidad asset-storage. Corrige la selección del paso o registra el servicio y vuelve a iniciarlo.",
         "binary_output_generator_invalid": "Un paso que genera salidas binarias selecciona una integración generativa que esta instalación no registra, o ninguna de las integraciones seleccionadas produce un tipo de contenido que el paso debe entregar. Las integraciones generativas se registran en el código de la instalación, no en este espacio de trabajo: regístrala o corrige la selección del paso y vuelve a iniciar.",
         "foundational_service_not_inherited": "La exclusión se aplica a un servicio heredado de la cuenta. Este id está registrado por este tablero, así que no hay nada que excluir: elimina la entrada propia del tablero.",
+        "input_gate_not_parked": "Esta ejecución ya no espera su comprobación de entrada. Puede que alguien la haya respondido o que la ejecución haya avanzado.",
+        "input_gate_parked": "Esta ejecución está detenida en su comprobación de entrada, que la vía de aprobación no puede resolver. Usa el aviso de la ejecución: corrige la tarea y vuelve a comprobar, o ejecútala de todos modos.",
         "ticket_already_linked": "Una incidencia solo puede respaldar una tarea, así que volver a vincularla dejaría a la tarea existente sin el contexto con el que se creó. Abre esa tarea o desvincula antes la incidencia.",
         "dry_run_not_mergeable": "Esta pull request proviene de una ejecución de prueba, así que no se puede fusionar desde aquí. Vuelve a iniciar la tarea como ejecución real para producir una pull request que este espacio de trabajo sí fusionará."
       },
@@ -3159,6 +3163,16 @@
         "saveFailed": "No se pudo guardar la configuración",
         "budgetSaved": "Presupuesto guardado",
         "budgetSaveFailed": "No se pudo guardar el presupuesto"
+      },
+      "inputGate": {
+        "heading": "Comprobación de entrada antes de iniciar una ejecución",
+        "body": "Revisa la redacción de la tarea antes de lanzar el primer paso del agente, para que una tarea inabordable se detenga sin gastar nada. Estándar detiene la ejecución ante una descripción vacía o de relleno, un error sin contexto de reproducción, o una tarea de revisión sin pull request.",
+        "mode": "Modo",
+        "modes": {
+          "standard": "Estándar (detener ante una carencia bloqueante)",
+          "advisory": "Aviso (registrar, nunca detener)",
+          "off": "Desactivado (omitir la comprobación)"
+        }
       }
     },
     "localModelEndpoints": {
@@ -4543,6 +4557,51 @@
       "fail": "Ejecución fallida"
     }
   },
+  "inputGate": {
+    "blockedTitle": "Esta tarea necesita más detalle antes de ejecutarse",
+    "blockedBody": "La ejecución se detuvo antes del primer paso del agente, así que no se ha gastado nada. Completa lo que falta en la tarea y vuelve a comprobar.",
+    "waivedTitle": "Iniciada pese a una tarea incompleta",
+    "waivedBody": "Alguien decidió ejecutar esta tarea con las carencias de abajo aún abiertas. Se conservan como parte del historial de la ejecución.",
+    "advisoryTitle": "Se anotaron algunas carencias y la ejecución continuó",
+    "advisoryBody": "La comprobación de entrada de la tarea encontró esto al iniciar la ejecución. Nada de ello detiene el trabajo, así que no se detuvo nada; completarlo facilita acertar en la próxima ejecución.",
+    "severity": {
+      "blocking": "Bloqueante",
+      "advisory": "Aviso"
+    },
+    "recheck": "Volver a comprobar",
+    "proceed": "Ejecutar igualmente",
+    "recheckHint": "La comprobación lee la tarea tal como está ahora, así que edítala primero.",
+    "issue": {
+      "description_missing": {
+        "title": "Sin descripción",
+        "hint": "El título nombra la tarea; la descripción es con lo que trabaja un agente. Di qué debe cambiar y por qué."
+      },
+      "description_placeholder": {
+        "title": "Descripción de relleno",
+        "hint": "La descripción es un marcador (\"TBD\", \"n/a\", \"arreglarlo\") en vez de una descripción del trabajo."
+      },
+      "description_thin": {
+        "title": "Descripción muy breve",
+        "hint": "Unas pocas palabras rara vez definen qué significa \"terminado\". Más detalle aquí ahorra una ronda de preguntas después."
+      },
+      "reproduction_missing": {
+        "title": "Sin contexto de reproducción",
+        "hint": "Un error sin pasos, sin observado frente a esperado y sin traza no permite saber cuándo queda corregido."
+      },
+      "review_target_missing": {
+        "title": "Sin pull request que revisar",
+        "hint": "Una tarea de revisión necesita el número o la URL del pull request que debe leer."
+      },
+      "success_criteria_missing": {
+        "title": "Sin criterios de éxito",
+        "hint": "Indica la pregunta que responde el spike, o cómo sería un buen resultado, para que el tiempo acotado tenga un objetivo."
+      },
+      "unknown": {
+        "title": "Hallazgo no reconocido",
+        "hint": "Esta ejecución registró una comprobación que esta versión ya no conoce. Revisa la tarea a mano antes de continuar."
+      }
+    }
+  },
   "requirements": {
     "title": "Revisión de requisitos",
     "iteration": "Iteración {current} / {max}",

package/i18n/locales/fr.json

@@ -566,6 +566,8 @@
         "binary_output_service_invalid": "Service des sorties binaires introuvable",
         "binary_output_generator_invalid": "Générateur de sorties binaires introuvable",
         "foundational_service_not_inherited": "Ce tableau a enregistré ce service",
+        "input_gate_not_parked": "Rien à répondre",
+        "input_gate_parked": "Répondez-y dans la vérification d'entrée de la tâche",
         "ticket_already_linked": "Ce ticket a déjà une tâche",
         "dry_run_not_mergeable": "Une exécution à blanc ne peut pas être fusionnée"
       },
@@ -600,6 +602,8 @@
         "binary_output_service_invalid": "Une étape qui génère des sorties binaires sélectionne un service fondamental que le catalogue de cet espace de travail ne peut pas résoudre : l’identifiant est inconnu, ou le service de stockage choisi ne porte pas la capacité asset-storage. Corrigez la sélection de l’étape ou enregistrez le service, puis relancez.",
         "binary_output_generator_invalid": "Une étape qui génère des sorties binaires sélectionne une intégration générative que ce déploiement n’enregistre pas, ou aucune des intégrations sélectionnées ne produit un type de contenu que l’étape doit livrer. Les intégrations génératives sont enregistrées dans le code du déploiement, pas dans cet espace de travail : enregistrez-la ou corrigez la sélection de l’étape, puis relancez.",
         "foundational_service_not_inherited": "L'écartement s'applique à un service hérité du compte. Cet identifiant est enregistré par ce tableau : il n'y a donc rien à écarter - supprimez plutôt l'entrée propre au tableau.",
+        "input_gate_not_parked": "Cette exécution n'attend plus sa vérification d'entrée. Quelqu'un y a peut-être déjà répondu, ou l'exécution a avancé.",
+        "input_gate_parked": "Cette exécution est en attente de sa vérification d'entrée, à laquelle la validation ne peut pas répondre. Utilisez l'avis sur l'exécution : corrigez la tâche et relancez la vérification, ou exécutez-la quand même.",
         "ticket_already_linked": "Un ticket ne peut alimenter qu'une seule tâche : le relier à nouveau priverait la tâche existante du contexte avec lequel elle a été créée. Ouvrez plutôt cette tâche, ou dissociez d'abord le ticket.",
         "dry_run_not_mergeable": "Cette pull request provient d'une exécution à blanc et ne peut pas être fusionnée ici. Relancez la tâche en exécution réelle pour produire une pull request que cet espace de travail fusionnera."
       },
@@ -3159,6 +3163,16 @@
         "saveFailed": "Impossible d'enregistrer les paramètres",
         "budgetSaved": "Budget enregistré",
         "budgetSaveFailed": "Impossible d'enregistrer le budget"
+      },
+      "inputGate": {
+        "heading": "Vérification des entrées avant le démarrage d'une exécution",
+        "body": "Contrôle la formulation d'une tâche avant l'envoi du premier pas de l'agent, pour qu'une tâche inexploitable s'arrête sans rien dépenser. Standard met l'exécution en pause sur une description vide ou de remplissage, un bogue sans contexte de reproduction, ou une tâche de relecture sans pull request.",
+        "mode": "Mode",
+        "modes": {
+          "standard": "Standard (mettre en pause sur un manque bloquant)",
+          "advisory": "Indicatif (enregistrer, jamais mettre en pause)",
+          "off": "Désactivé (ignorer la vérification)"
+        }
       }
     },
     "localModelEndpoints": {
@@ -4543,6 +4557,51 @@
       "fail": "Exécution échouée"
     }
   },
+  "inputGate": {
+    "blockedTitle": "Cette tâche a besoin de plus de détails avant de s'exécuter",
+    "blockedBody": "L'exécution s'est arrêtée avant le premier pas de l'agent, rien n'a donc été dépensé. Complétez ce qui manque sur la tâche, puis relancez la vérification.",
+    "waivedTitle": "Démarrée malgré une tâche incomplète",
+    "waivedBody": "Quelqu'un a choisi d'exécuter cette tâche avec les manques ci-dessous encore ouverts. Ils sont conservés dans l'historique de l'exécution.",
+    "advisoryTitle": "Quelques manques relevés, l'exécution a continué",
+    "advisoryBody": "La vérification d'entrée de la tâche les a repérés au démarrage. Aucun n'empêche le travail, rien n'a donc été mis en attente : les compléter facilitera la prochaine exécution.",
+    "severity": {
+      "blocking": "Bloquant",
+      "advisory": "Indicatif"
+    },
+    "recheck": "Revérifier la tâche",
+    "proceed": "Exécuter quand même",
+    "recheckHint": "La vérification lit la tâche telle qu'elle est maintenant, modifiez-la d'abord.",
+    "issue": {
+      "description_missing": {
+        "title": "Aucune description",
+        "hint": "Le titre nomme la tâche ; la description est ce sur quoi un agent travaille. Dites ce qui doit changer et pourquoi."
+      },
+      "description_placeholder": {
+        "title": "Description de remplissage",
+        "hint": "La description est un substitut (\"TBD\", \"n/a\", \"à corriger\") plutôt qu'un énoncé du travail."
+      },
+      "description_thin": {
+        "title": "Description très courte",
+        "hint": "Quelques mots définissent rarement ce que \"terminé\" veut dire. Plus de détail ici évite un aller-retour de questions."
+      },
+      "reproduction_missing": {
+        "title": "Aucun contexte de reproduction",
+        "hint": "Un bogue sans étapes, sans observé-contre-attendu et sans trace d'appels ne permet pas de savoir quand il est corrigé."
+      },
+      "review_target_missing": {
+        "title": "Aucune pull request à relire",
+        "hint": "Une tâche de relecture a besoin du numéro ou de l'URL de la pull request à lire."
+      },
+      "success_criteria_missing": {
+        "title": "Aucun critère de réussite",
+        "hint": "Indiquez la question à laquelle le spike répond, ou ce qu'est un bon résultat, pour donner une cible au temps imparti."
+      },
+      "unknown": {
+        "title": "Constat non reconnu",
+        "hint": "Cette exécution a enregistré une vérification que cette version ne connaît plus. Relisez la tâche à la main avant de continuer."
+      }
+    }
+  },
   "requirements": {
     "title": "Revue des exigences",
     "iteration": "Itération {current} / {max}",