@cat-factory/app 0.223.0 → 0.224.0

package/app/components/inputGate/InputGateNotice.vue

@@ -64,6 +64,10 @@ const ISSUE_KEYS = {
     title: 'inputGate.issue.success_criteria_missing.title',
     hint: 'inputGate.issue.success_criteria_missing.hint',
   },
+  required_field_missing: {
+    title: 'inputGate.issue.required_field_missing.title',
+    hint: 'inputGate.issue.required_field_missing.hint',
+  },
 } as const satisfies Record<InputGateIssueCode, { title: string; hint: string }>
 
 /**
@@ -87,16 +91,30 @@ const TONE_COPY: Record<InputGateTone, { title: string; body: string }> = {
 }
 const copy = computed(() => TONE_COPY[props.tone])
 
+/**
+ * The interpolation a finding's copy is rendered with. Only `required_field_missing` carries a
+ * `field`, and its copy is the one line that cannot be written without knowing which input is
+ * missing: a deployment registers its own task types, so the platform has no vocabulary for
+ * "the incident's severity" and names the field instead. The label is deployment-supplied
+ * English, exactly as a custom agent kind's is.
+ *
+ * A finding whose `field` is somehow absent still renders: the copy falls back to naming no
+ * field rather than printing `undefined` into a sentence a human is meant to act on.
+ */
+function issueValues(issue: InputGateIssue): Record<string, string> {
+  return { field: issue.field?.label ?? t('inputGate.issue.required_field_missing.unnamedField') }
+}
+
 /** A finding's translated title, falling back to the generic line for a retired code. */
-function issueTitle(code: InputGateIssueCode): string {
-  const key = ISSUE_KEYS[code]?.title
-  return key && te(key) ? t(key) : t('inputGate.issue.unknown.title')
+function issueTitle(issue: InputGateIssue): string {
+  const key = ISSUE_KEYS[issue.code]?.title
+  return key && te(key) ? t(key, issueValues(issue)) : t('inputGate.issue.unknown.title')
 }
 
 /** A finding's translated remedy hint, on the same fallback. */
-function issueHint(code: InputGateIssueCode): string {
-  const key = ISSUE_KEYS[code]?.hint
-  return key && te(key) ? t(key) : t('inputGate.issue.unknown.hint')
+function issueHint(issue: InputGateIssue): string {
+  const key = ISSUE_KEYS[issue.code]?.hint
+  return key && te(key) ? t(key, issueValues(issue)) : t('inputGate.issue.unknown.hint')
 }
 
 async function resolve(choice: 'recheck' | 'proceed') {
@@ -126,7 +144,11 @@ async function resolve(choice: 'recheck' | 'proceed') {
         <p v-if="!compact" class="text-muted mt-0.5 text-xs">{{ t(copy.body) }}</p>
 
         <ul class="mt-2 space-y-1.5">
-          <li v-for="issue in issues" :key="issue.code" class="flex items-start gap-2 text-xs">
+          <li
+            v-for="issue in issues"
+            :key="`${issue.code}:${issue.field?.key ?? ''}`"
+            class="flex items-start gap-2 text-xs"
+          >
             <UBadge
               :color="issue.severity === 'blocking' ? 'warning' : 'neutral'"
               variant="subtle"
@@ -139,8 +161,8 @@ async function resolve(choice: 'recheck' | 'proceed') {
               }}
             </UBadge>
             <span class="min-w-0">
-              <span class="font-medium">{{ issueTitle(issue.code) }}</span>
-              <span class="text-muted">, {{ issueHint(issue.code) }}</span>
+              <span class="font-medium">{{ issueTitle(issue) }}</span>
+              <span class="text-muted">, {{ issueHint(issue) }}</span>
             </span>
           </li>
         </ul>

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

@@ -0,0 +1,115 @@
+<script setup lang="ts">
+// The answers to a CUSTOM task type's own declared fields, editable after creation.
+//
+// Why it exists: the create form is not the only door a task arrives through (the public API, an
+// initiative spawn, a tracker import), and a type's declaration can get STRICTER after a task
+// already exists. The pre-dispatch input gate judges the declaration as it stands now, so it
+// parks runs whose task predates the requirement. Without this panel that park had exactly one
+// exit, a human waiving the gate: `recheck` would re-read the same unanswered bag forever, and
+// the remedy the notice names ("fill it in on the task") would be one nothing offered.
+//
+// Renders through the SAME `DescriptorFields` component the create form uses, against the SAME
+// declaration, validated by the SAME shared rule. A field the form would have hidden by its
+// `showWhen` is hidden here too, so the two doors cannot show a person different questions.
+import { computed, ref, watch } from 'vue'
+import type { DescriptorFieldValues } from '@cat-factory/contracts'
+import { sanitizeDescriptorFields, validateDescriptorFields } from '@cat-factory/contracts'
+import type { Block } from '~/types/domain'
+import DescriptorFields from '~/components/common/DescriptorFields.vue'
+import InspectorSection from '~/components/panels/inspector/InspectorSection.vue'
+
+const props = defineProps<{ block: Block }>()
+
+const board = useBoardStore()
+const taskTypes = useTaskTypesStore()
+const { t } = useI18n()
+
+/** The registered type this task is, or undefined for a built-in / unregistered one. */
+const descriptor = computed(() =>
+  props.block.taskType
+    ? taskTypes.customTaskTypes.find((tt) => tt.taskType === props.block.taskType)
+    : undefined,
+)
+
+/**
+ * The fields to render. A type carrying a bespoke `formPanel` owns its whole bag, so its
+ * descriptor fields are not what was collected and editing them here would write values its own
+ * form never offered. That is the same stand-down the create door and the input gate take, and
+ * all three have to agree or "the declaration" would mean three different things.
+ */
+const fields = computed(() => (descriptor.value?.formPanel ? [] : (descriptor.value?.fields ?? [])))
+
+const stored = computed<DescriptorFieldValues>(() => props.block.taskTypeFields?.custom ?? {})
+
+// Local edit buffer, re-seeded whenever the stored bag changes underneath (a live board push, or
+// switching blocks). Editing writes on commit rather than per keystroke, so a half-typed answer
+// never reaches the row the gate reads.
+const draft = ref<DescriptorFieldValues>({ ...stored.value })
+watch(stored, (next) => {
+  draft.value = { ...next }
+})
+
+/**
+ * The same check the server runs, so the button reflects an invalid form rather than the save
+ * failing with a 422. Shared from contracts precisely so the two cannot drift.
+ */
+const problems = computed(() => validateDescriptorFields(fields.value, draft.value))
+
+const dirty = computed(
+  () =>
+    JSON.stringify(sanitizeDescriptorFields(fields.value, draft.value)) !==
+    JSON.stringify(stored.value),
+)
+
+const saving = ref(false)
+
+async function save() {
+  if (problems.value.length || !dirty.value) return
+  saving.value = true
+  try {
+    await board.updateBlock(props.block.id, {
+      customTaskTypeFields: sanitizeDescriptorFields(fields.value, draft.value),
+    })
+  } finally {
+    saving.value = false
+  }
+}
+
+function revert() {
+  draft.value = { ...stored.value }
+}
+</script>
+
+<template>
+  <InspectorSection
+    v-if="fields.length"
+    :title="t('inspector.taskTypeFields.title')"
+    :hint="t('inspector.taskTypeFields.hint')"
+    icon="i-lucide-clipboard-list"
+    :count="fields.length"
+  >
+    <DescriptorFields v-model="draft" :fields="fields" testid-prefix="task-type-field" />
+    <div v-if="dirty" class="mt-2 flex items-center gap-2">
+      <UButton
+        size="xs"
+        color="primary"
+        variant="soft"
+        :loading="saving"
+        :disabled="problems.length > 0"
+        data-testid="task-type-fields-save"
+        @click="save"
+      >
+        {{ t('inspector.taskTypeFields.save') }}
+      </UButton>
+      <UButton
+        size="xs"
+        color="neutral"
+        variant="ghost"
+        data-testid="task-type-fields-revert"
+        @click="revert"
+      >
+        {{ t('inspector.taskTypeFields.revert') }}
+      </UButton>
+    </div>
+  </InspectorSection>
+</template>

package/app/components/provisioning/ProvisioningLogsDrawer.vue

@@ -88,6 +88,7 @@ onBeforeUnmount(() => {
 const OPERATION_LABEL = computed<Record<ProvisioningOperation, string>>(() => ({
   provision: t('provisioning.operation.provision'),
   teardown: t('provisioning.operation.teardown'),
+  'teardown-verify': t('provisioning.operation.teardown-verify'),
   status: t('provisioning.operation.status'),
   dispatch: t('provisioning.operation.dispatch'),
   release: t('provisioning.operation.release'),

package/app/modular/panels/inspector.logic.spec.ts

@@ -97,6 +97,11 @@ describe('inspector panel group', () => {
       'task-dependencies',
       'task-run-settings',
       'task-agent-config',
+      // The custom type's own declared fields sit with the other task INPUTS (what the task is),
+      // not under run settings (how it runs). It is gated on being a task alone: the panel hides
+      // itself unless the type is one this deployment registered with descriptor fields, which
+      // the spec here cannot see and should not try to.
+      'task-type-fields',
       'task-structure',
     ])
   })

package/app/modular/panels/inspector.logic.ts

@@ -45,6 +45,7 @@ export const INSPECTOR_PANEL_IDS = [
   'task-dependencies',
   'task-run-settings',
   'task-agent-config',
+  'task-type-fields',
   'task-structure',
   // service / module body
   'container-summary',
@@ -134,6 +135,11 @@ export const INSPECTOR_PANEL_SPECS: readonly InspectorPanelSpec[] = [
   { id: 'task-dependencies', order: 60, when: isTask },
   { id: 'task-run-settings', order: 70, when: isTask },
   { id: 'task-agent-config', order: 80, when: isTask },
+  // The answers to a CUSTOM task type's declared fields. Gated on being a task alone; the panel
+  // itself hides unless the task's type is one this deployment registered WITH descriptor fields,
+  // which is the only case there is anything to edit. It sits beside the other task inputs rather
+  // than under Run settings: these are what the task IS, not how it runs.
+  { id: 'task-type-fields', order: 85, when: isTask },
   { id: 'task-structure', order: 90, when: isTask },
   { id: 'container-summary', order: 110, when: isContainer },
   { id: 'frontend-config', order: 120, when: (b) => isFrame(b) && b.type === 'frontend' },

package/app/modular/panels/inspector.ts

@@ -21,6 +21,7 @@ import TaskEstimateBadge from '~/components/panels/inspector/TaskEstimateBadge.v
 import TaskDependencies from '~/components/panels/inspector/TaskDependencies.vue'
 import TaskRunSettings from '~/components/panels/inspector/TaskRunSettings.vue'
 import TaskAgentConfig from '~/components/panels/inspector/TaskAgentConfig.vue'
+import TaskTypeFields from '~/components/panels/inspector/TaskTypeFields.vue'
 import TaskStructure from '~/components/panels/inspector/TaskStructure.vue'
 import ContainerSummary from '~/components/panels/inspector/ContainerSummary.vue'
 import FrontendConfig from '~/components/panels/inspector/FrontendConfig.vue'
@@ -75,6 +76,7 @@ const COMPONENTS: Record<InspectorPanelId, Component> = {
   'task-dependencies': TaskDependencies,
   'task-run-settings': TaskRunSettings,
   'task-agent-config': TaskAgentConfig,
+  'task-type-fields': TaskTypeFields,
   'task-structure': TaskStructure,
   'container-summary': ContainerSummary,
   'frontend-config': FrontendConfig,

package/app/stores/agents.ts

@@ -7,6 +7,7 @@ import {
   AGENT_ARCHETYPES,
   AGENT_BY_KIND,
   setCustomAgentKindMeta,
+  setCustomCompanionTargets,
   SYSTEM_AGENT_META,
   uid,
 } from '~/utils/catalog'
@@ -105,6 +106,28 @@ export const useAgentsStore = defineStore('agents', () => {
   // no tick gap. The watch lives in the store's effect scope (disposed with it).
   watch(customByKind, (map) => setCustomAgentKindMeta(map), { immediate: true, flush: 'sync' })
 
+  /**
+   * The custom COMPANION pairings (companion kind → the producer kinds it reviews), read off the
+   * same custom-kind sources the palette is built from. Kept apart from `customByKind` because a
+   * pairing is not display metadata: the builder uses it to decide a kind is a TOGGLE on its
+   * producer rather than a placeable block, and `AgentArchetype` has no business carrying it.
+   */
+  const customCompanions = computed<Record<string, readonly AgentKind[]>>(() => {
+    const out: Record<string, readonly AgentKind[]> = {}
+    const add = (k: CustomAgentKind) => {
+      // A pairing with no targets is not a pairing. Recording it would make the kind vanish from
+      // the palette (an `isProducerCompanion` hit) with no producer to hang the toggle on.
+      if (k.companionTargets?.length) out[k.kind] = k.companionTargets
+    }
+    for (const k of consumerKinds.value) add(k)
+    for (const k of capabilitiesManifest.value?.slots?.agentKinds ?? []) add(k)
+    return out
+  })
+  watch(customCompanions, (map) => setCustomCompanionTargets(map), {
+    immediate: true,
+    flush: 'sync',
+  })
+
   /** Display metadata for a KNOWN kind (built-in / system / custom), else undefined. */
   function get(kind: AgentKind): AgentArchetype | undefined {
     return AGENT_BY_KIND[kind] ?? SYSTEM_AGENT_META[kind] ?? customByKind.value[kind]

package/app/utils/catalog.companions.spec.ts

@@ -0,0 +1,80 @@
+import { afterEach, describe, expect, it } from 'vitest'
+import type { AgentKind } from '~/types/domain'
+import {
+  COMPANION_FOR_PRODUCER,
+  __resetCustomCompanionTargetsForTest,
+  companionForProducer,
+  isProducerCompanion,
+  setCustomCompanionTargets,
+} from '~/utils/catalog'
+
+// The SPA half of the companion registry. A companion is not a placeable palette block: the
+// builder renders it as an "add companion" toggle ON its producer and inserts it immediately
+// after. These two lookups are what decide that, so a deployment's registered pair is either
+// visible as a toggle or invisible entirely, with nothing in between.
+//
+// The backend half is `extension-registries.companions.test.ts`. Both are needed: the backend
+// enforces the adjacency rule on save, and this decides whether a person can ever express the
+// pairing in the first place.
+
+afterEach(() => {
+  __resetCustomCompanionTargetsForTest()
+})
+
+describe('custom companion pairings in the palette', () => {
+  it('has no opinion about a deployment’s pair until the store projects it', () => {
+    // The pre-registration state is a real one: the snapshot arrives after first paint, and a
+    // custom companion must degrade to an ordinary kind rather than to a broken toggle.
+    expect(isProducerCompanion('acme:migration-auditor')).toBe(false)
+    expect(companionForProducer('acme:migrator')).toBeUndefined()
+  })
+
+  it('renders a registered pair as a toggle on its producer', () => {
+    setCustomCompanionTargets({ 'acme:migration-auditor': ['acme:migrator'] })
+    expect(companionForProducer('acme:migrator')).toBe('acme:migration-auditor')
+    // ...and the companion itself leaves the palette, which is the other half of "it is a
+    // toggle, not a block". Registering only one of these would show the kind twice.
+    expect(isProducerCompanion('acme:migration-auditor')).toBe(true)
+    // The producer is not a companion just for being reviewed by one.
+    expect(isProducerCompanion('acme:migrator')).toBe(false)
+  })
+
+  it('lets one companion review several producers', () => {
+    setCustomCompanionTargets({ 'acme:auditor': ['acme:migrator', 'acme:packager'] })
+    expect(companionForProducer('acme:migrator')).toBe('acme:auditor')
+    expect(companionForProducer('acme:packager')).toBe('acme:auditor')
+  })
+
+  it('never lets a deployment re-point a BUILT-IN producer at its own companion', () => {
+    // Built-ins win, matching `agentKindMeta`'s precedence and the backend registry's refusal to
+    // shadow a built-in kind. The shipped pairing is what every stock pipeline relies on, so a
+    // silent re-point would change what those pipelines do without anyone editing them.
+    setCustomCompanionTargets({ 'acme:reviewer': ['coder'] })
+    expect(companionForProducer('coder')).toBe(COMPANION_FOR_PRODUCER.coder)
+    // The custom kind still leaves the palette: it IS a companion, it just does not get `coder`.
+    expect(isProducerCompanion('acme:reviewer')).toBe(true)
+  })
+
+  it('resolves a contested producer deterministically, first registration winning', () => {
+    // Only one toggle can hang off a producer, so two companions claiming it is a case with an
+    // answer whether or not anyone chose one. Pinning it here is what keeps the answer from
+    // being "whichever the object happened to enumerate first".
+    const contested: Record<string, readonly AgentKind[]> = {
+      'acme:first': ['acme:migrator'],
+      'acme:second': ['acme:migrator'],
+    }
+    setCustomCompanionTargets(contested)
+    expect(companionForProducer('acme:migrator')).toBe('acme:first')
+    expect(isProducerCompanion('acme:second')).toBe(true)
+  })
+
+  it('drops a pairing when the catalog it came from goes away', () => {
+    setCustomCompanionTargets({ 'acme:migration-auditor': ['acme:migrator'] })
+    expect(companionForProducer('acme:migrator')).toBe('acme:migration-auditor')
+    // A workspace switch re-projects an empty catalog. The lookups must follow it rather than
+    // keep answering from the old deployment's registrations.
+    setCustomCompanionTargets({})
+    expect(companionForProducer('acme:migrator')).toBeUndefined()
+    expect(isProducerCompanion('acme:migration-auditor')).toBe(false)
+  })
+})

package/app/utils/catalog.spec.ts

@@ -37,6 +37,7 @@ const AGENT_KINDS: AgentKind[] = [
   'business-reviewer',
   'human-test',
   'visual-confirmation',
+  'disposer',
 ]
 const BLOCK_TYPES: BlockType[] = [
   'frontend',

package/app/utils/catalog.ts

@@ -1,4 +1,4 @@
-import { shallowRef } from 'vue'
+import { computed, shallowRef } from 'vue'
 import type {
   AgentArchetype,
   AgentCategory,
@@ -228,6 +228,21 @@ export const AGENT_ARCHETYPES: AgentArchetype[] = [
     // recreate / destroy) instead of the generic prose step-detail panel.
     resultView: 'human-test',
   },
+  {
+    // The `deployer`'s counterpart at the other end of the environment lifecycle, and a PALETTE
+    // block rather than a system kind precisely because deciding WHEN the environment goes away
+    // is the point of it: after the automated tester, or after a human has finished with the live
+    // URL. Without one, the TTL sweep reclaims environments on a timer long after the run
+    // settled, which is a fine backstop and cannot close the run's own teardown proof.
+    kind: 'disposer',
+    tier: 'intermediate',
+    label: 'Disposer',
+    icon: 'i-lucide-cloud-off',
+    color: '#34d399',
+    category: 'test',
+    description:
+      'Reclaims the ephemeral environments this run provisioned, and confirms they are actually gone. Place it after the last step that needs the environment.',
+  },
   {
     kind: 'visual-confirmation',
     tier: 'advanced',
@@ -322,9 +337,13 @@ export const COMPANION_ARCHETYPES: AgentArchetype[] = [
 ]
 
 /**
- * Producer agent kind → its companion agent kind. Mirrors the backend `COMPANIONS` registry
- * (`@cat-factory/agents`). The builder shows an "add companion" toggle on a producer step
- * found here, and inserts/removes the companion immediately after it.
+ * Producer agent kind → its companion agent kind, for the BUILT-IN pairs. Mirrors the backend
+ * `COMPANIONS` catalog (`@cat-factory/agents`). The builder shows an "add companion" toggle on
+ * a producer step found here, and inserts/removes the companion immediately after it.
+ *
+ * A DEPLOYMENT's own pair does not live here: it arrives on the snapshot as a custom agent
+ * kind carrying `companionTargets`, and is projected into {@link customCompanionTargets} by the
+ * agents store. Both are consulted below, built-ins first.
  */
 export const COMPANION_FOR_PRODUCER: Record<string, AgentKind> = {
   coder: 'reviewer',
@@ -335,18 +354,67 @@ export const COMPANION_FOR_PRODUCER: Record<string, AgentKind> = {
 
 const COMPANION_KINDS: ReadonlySet<string> = new Set(COMPANION_ARCHETYPES.map((a) => a.kind))
 
-/** The companion kind that depends on a producer kind, or undefined if it has none. */
+/**
+ * Reactive read-model of the deployment's CUSTOM companion pairings (companion kind → the
+ * producer kinds it reviews), kept in sync by the agents store from the snapshot's
+ * `customAgentKinds[].companionTargets`.
+ *
+ * A `shallowRef` for the same reason {@link customAgentKindMeta} is one: the pure lookups below
+ * must resolve a registered companion, and re-render when the catalog changes, without importing
+ * the store (circular) or mutating the frozen built-in map. Empty until the store first
+ * populates it, so a custom companion degrades to "not a companion" (an ordinary palette block),
+ * exactly as before registration.
+ */
+const customCompanionTargets = shallowRef<Record<string, readonly AgentKind[]>>({})
+
+/**
+ * The same projection INVERTED: producer kind → the companion that reviews it, the direction
+ * {@link companionForProducer} actually asks in. Derived rather than scanned per call, because
+ * that lookup runs once per step of every pipeline the builder renders.
+ *
+ * Inverting is also where an ambiguity has to be RESOLVED rather than left to iteration order:
+ * two registered companions may both claim a producer, and only one toggle can hang off it.
+ * First registration wins, stated here once, instead of "whichever `Object.entries` reached
+ * first" being the answer at each call site.
+ */
+const customCompanionByProducer = computed<Record<string, AgentKind>>(() => {
+  const out: Record<string, AgentKind> = {}
+  for (const [companion, targets] of Object.entries(customCompanionTargets.value)) {
+    for (const producer of targets) if (!(producer in out)) out[producer] = companion
+  }
+  return out
+})
+
+/** Replace the custom companion projection (called only by the agents store). */
+export function setCustomCompanionTargets(map: Record<string, readonly AgentKind[]>): void {
+  customCompanionTargets.value = map
+}
+
+/** Test-only: clear the custom companion projection so a spec starts from built-ins only. */
+export function __resetCustomCompanionTargetsForTest(): void {
+  customCompanionTargets.value = {}
+}
+
+/**
+ * The companion kind that depends on a producer kind, or undefined if it has none.
+ *
+ * Built-ins win. A deployment cannot re-point `coder` at its own reviewer by registering one,
+ * for the same reason `agentKindMeta`'s precedence puts built-ins first and the backend registry
+ * never shadows a built-in kind: the shipped pairing is the one the engine's own pipelines rely
+ * on, and a silent re-point would change what every stock pipeline does.
+ */
 export function companionForProducer(kind: string): AgentKind | undefined {
-  return COMPANION_FOR_PRODUCER[kind]
+  return COMPANION_FOR_PRODUCER[kind] ?? customCompanionByProducer.value[kind]
 }
 
 /**
  * Whether a kind is a dependent producer-companion (reviewer / architect-companion /
- * spec-companion) — rendered as a toggle on its producer, not a standalone palette block.
- * Distinct from `pipelineRender`'s `isCompanionKind`, which also counts the Tester's `fixer`.
+ * spec-companion, or a deployment's own): rendered as a toggle on its producer, not a
+ * standalone palette block. Distinct from `pipelineRender`'s `isCompanionKind`, which also
+ * counts the Tester's `fixer`.
  */
 export function isProducerCompanion(kind: string): boolean {
-  return COMPANION_KINDS.has(kind)
+  return COMPANION_KINDS.has(kind) || kind in customCompanionTargets.value
 }
 
 /**

package/i18n/locales/de.json

@@ -1533,6 +1533,12 @@
       "inherited": "vom Service geerbt",
       "frozen": "Eingefroren: der Agent hat gestartet"
     },
+    "taskTypeFields": {
+      "title": "Aufgabentyp-Felder",
+      "hint": "Die Antworten, die dieser Aufgabentyp benötigt. Fehlt eine Pflichtangabe, wird ein Lauf vor dem Start angehalten.",
+      "save": "Speichern",
+      "revert": "Zurücksetzen"
+    },
     "dependencies": {
       "title": "Hängt ab von",
       "hint": "Aufgaben, die gemergt sein müssen, bevor diese laufen kann. Das Run-Steuerelement bleibt gesperrt, bis jede Abhängigkeit erledigt ist.",
@@ -5561,6 +5567,11 @@
         "title": "Keine Erfolgskriterien",
         "hint": "Nenne die Frage, die der Spike beantwortet, oder wie ein gutes Ergebnis aussieht, damit die Zeitbox ein Ziel hat."
       },
+      "required_field_missing": {
+        "title": "Fehlt: {field}",
+        "hint": "Dieser Aufgabentyp verlangt „{field}“, die Aufgabe beantwortet es aber nicht. Trage es an der Aufgabe nach und prüfe erneut.",
+        "unnamedField": "ein Pflichtfeld"
+      },
       "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."
@@ -5914,6 +5925,7 @@
     "operation": {
       "provision": "Hochfahren",
       "teardown": "Abbauen",
+      "teardown-verify": "Abbau-Prüfung",
       "status": "Statusprüfung",
       "dispatch": "Hochfahren",
       "release": "Abbauen",

package/i18n/locales/en.json

@@ -1087,6 +1087,12 @@
       "inherited": "inherited from service",
       "frozen": "Frozen: the agent has started"
     },
+    "taskTypeFields": {
+      "title": "Task type fields",
+      "hint": "The answers this task type declares it needs. A required answer that is missing parks a run before it starts.",
+      "save": "Save",
+      "revert": "Revert"
+    },
     "dependencies": {
       "title": "Depends on",
       "hint": "Tasks that must merge before this one can run. The Run control stays locked until every dependency is done.",
@@ -4911,6 +4917,11 @@
         "title": "No success criteria",
         "hint": "State the question the spike answers, or what a good outcome looks like, so the timebox has a target."
       },
+      "required_field_missing": {
+        "title": "Missing: {field}",
+        "hint": "This task type requires “{field}”, and the task does not answer it. Fill it in on the task, then re-check.",
+        "unnamedField": "a required field"
+      },
       "unknown": {
         "title": "Unrecognised finding",
         "hint": "This run recorded a check this version no longer knows about. Review the task by hand before continuing."
@@ -5610,6 +5621,7 @@
     "operation": {
       "provision": "Spin up",
       "teardown": "Tear down",
+      "teardown-verify": "Teardown check",
       "status": "Status check",
       "dispatch": "Spin up",
       "release": "Tear down",

package/i18n/locales/es.json

@@ -1003,6 +1003,12 @@
       "inherited": "heredado del servicio",
       "frozen": "Congelado: el agente ya ha comenzado"
     },
+    "taskTypeFields": {
+      "title": "Campos del tipo de tarea",
+      "hint": "Las respuestas que este tipo de tarea declara necesitar. Si falta una respuesta obligatoria, la ejecución se detiene antes de empezar.",
+      "save": "Guardar",
+      "revert": "Descartar"
+    },
     "dependencies": {
       "title": "Depende de",
       "hint": "Tareas que deben fusionarse antes de que esta pueda ejecutarse. El control Ejecutar permanece bloqueado hasta que todas las dependencias estén completas.",
@@ -4703,6 +4709,11 @@
         "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."
       },
+      "required_field_missing": {
+        "title": "Falta: {field}",
+        "hint": "Este tipo de tarea requiere «{field}» y la tarea no lo responde. Complétalo en la tarea y vuelve a comprobar.",
+        "unnamedField": "un campo obligatorio"
+      },
       "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."
@@ -5359,6 +5370,7 @@
     "operation": {
       "provision": "Arrancar",
       "teardown": "Desmontar",
+      "teardown-verify": "Comprobación de desmontaje",
       "status": "Comprobación de estado",
       "dispatch": "Arrancar",
       "release": "Desmontar",

package/i18n/locales/fr.json

@@ -1003,6 +1003,12 @@
       "inherited": "hérité du service",
       "frozen": "Figé : l'agent a démarré"
     },
+    "taskTypeFields": {
+      "title": "Champs du type de tâche",
+      "hint": "Les réponses que ce type de tâche déclare nécessaires. Une réponse obligatoire manquante met l'exécution en pause avant son démarrage.",
+      "save": "Enregistrer",
+      "revert": "Rétablir"
+    },
     "dependencies": {
       "title": "Dépend de",
       "hint": "Tâches qui doivent être fusionnées avant que celle-ci puisse s'exécuter. Le contrôle Exécuter reste verrouillé tant que toutes les dépendances ne sont pas terminées.",
@@ -4703,6 +4709,11 @@
         "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."
       },
+      "required_field_missing": {
+        "title": "Manquant : {field}",
+        "hint": "Ce type de tâche exige « {field} », et la tâche n’y répond pas. Renseignez-le sur la tâche, puis revérifiez.",
+        "unnamedField": "un champ obligatoire"
+      },
       "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."
@@ -5359,6 +5370,7 @@
     "operation": {
       "provision": "Démarrer",
       "teardown": "Démanteler",
+      "teardown-verify": "Vérification du démantèlement",
       "status": "Vérification de l'état",
       "dispatch": "Démarrer",
       "release": "Démanteler",

package/i18n/locales/he.json

@@ -1003,6 +1003,12 @@
       "inherited": "נורש מהשירות",
       "frozen": "מוקפא: הסוכן כבר התחיל"
     },
+    "taskTypeFields": {
+      "title": "שדות סוג המשימה",
+      "hint": "התשובות שסוג משימה זה מצהיר שהוא זקוק להן. תשובת חובה חסרה עוצרת הרצה לפני שהיא מתחילה.",
+      "save": "שמירה",
+      "revert": "שחזור"
+    },
     "dependencies": {
       "title": "תלוי ב",
       "hint": "משימות שחייבות להתמזג לפני שמשימה זו תוכל לרוץ. פקד ההרצה נשאר נעול עד שכל התלויות הושלמו.",
@@ -4703,6 +4709,11 @@
         "title": "אין קריטריוני הצלחה",
         "hint": "ציינו את השאלה שהבדיקה המקדימה עונה עליה, או איך נראית תוצאה טובה, כדי שלמסגרת הזמן תהיה מטרה."
       },
+      "required_field_missing": {
+        "title": "חסר: {field}",
+        "hint": "סוג משימה זה מחייב את “{field}”, והמשימה אינה ממלאת אותו. מלאו אותו במשימה ובדקו שוב.",
+        "unnamedField": "שדה חובה"
+      },
       "unknown": {
         "title": "ממצא לא מוכר",
         "hint": "ההרצה תיעדה בדיקה שהגרסה הזו כבר לא מכירה. עברו על המשימה ידנית לפני שתמשיכו."
@@ -5359,6 +5370,7 @@
     "operation": {
       "provision": "הקמה",
       "teardown": "פירוק",
+      "teardown-verify": "בדיקת פירוק",
       "status": "בדיקת מצב",
       "dispatch": "הקמה",
       "release": "פירוק",

package/i18n/locales/it.json

@@ -1533,6 +1533,12 @@
       "inherited": "ereditato dal servizio",
       "frozen": "Congelato: l'agente e' partito"
     },
+    "taskTypeFields": {
+      "title": "Campi del tipo di attività",
+      "hint": "Le risposte che questo tipo di attività dichiara necessarie. Una risposta obbligatoria mancante mette in pausa l'esecuzione prima che inizi.",
+      "save": "Salva",
+      "revert": "Ripristina"
+    },
     "dependencies": {
       "title": "Dipende da",
       "hint": "Attivita' che devono essere unite prima che questa possa essere eseguita. Il controllo Esegui resta bloccato finche' ogni dipendenza non e' completata.",
@@ -5561,6 +5567,11 @@
         "title": "Nessun criterio di successo",
         "hint": "Indica la domanda a cui risponde lo spike, o come si presenta un buon esito, così il tempo riservato ha un obiettivo."
       },
+      "required_field_missing": {
+        "title": "Manca: {field}",
+        "hint": "Questo tipo di attività richiede «{field}» e l’attività non lo compila. Inseriscilo nell’attività, poi ricontrolla.",
+        "unnamedField": "un campo obbligatorio"
+      },
       "unknown": {
         "title": "Rilievo non riconosciuto",
         "hint": "Questa esecuzione ha registrato un controllo che questa versione non conosce più. Rivedi l'attività a mano prima di continuare."
@@ -5914,6 +5925,7 @@
     "operation": {
       "provision": "Avvio",
       "teardown": "Smantellamento",
+      "teardown-verify": "Verifica dello smantellamento",
       "status": "Controllo dello stato",
       "dispatch": "Avvio",
       "release": "Smantellamento",

package/i18n/locales/ja.json

@@ -1003,6 +1003,12 @@
       "inherited": "サービスから継承",
       "frozen": "固定: エージェントは開始済みです"
     },
+    "taskTypeFields": {
+      "title": "タスクタイプのフィールド",
+      "hint": "このタスクタイプが必要と宣言している回答です。必須の回答が欠けている場合、実行は開始前に保留されます。",
+      "save": "保存",
+      "revert": "元に戻す"
+    },
     "dependencies": {
       "title": "依存先",
       "hint": "このタスクを実行する前にマージされている必要があるタスク。すべての依存関係が完了するまで実行コントロールはロックされたままです。",
@@ -4703,6 +4709,11 @@
         "title": "成功条件がありません",
         "hint": "スパイクが答える問い、または良い結果の姿を書いて、時間枠に目標を与えてください。"
       },
+      "required_field_missing": {
+        "title": "未入力: {field}",
+        "hint": "このタスク種別は「{field}」を必須としていますが、タスクに入力がありません。タスクで入力してから再確認してください。",
+        "unnamedField": "必須項目"
+      },
       "unknown": {
         "title": "未知の指摘",
         "hint": "この実行には、このバージョンが把握していないチェックが記録されています。続行前にタスクを手動で確認してください。"
@@ -5359,6 +5370,7 @@
     "operation": {
       "provision": "起動",
       "teardown": "破棄",
+      "teardown-verify": "破棄の確認",
       "status": "ステータスチェック",
       "dispatch": "起動",
       "release": "破棄",

package/i18n/locales/pl.json

@@ -1003,6 +1003,12 @@
       "inherited": "odziedziczone z usługi",
       "frozen": "Zamrożone: agent został uruchomiony"
     },
+    "taskTypeFields": {
+      "title": "Pola typu zadania",
+      "hint": "Odpowiedzi, których wymaga ten typ zadania. Brak wymaganej odpowiedzi wstrzymuje uruchomienie przed startem.",
+      "save": "Zapisz",
+      "revert": "Przywróć"
+    },
     "dependencies": {
       "title": "Zależy od",
       "hint": "Zadania, które muszą zostać scalone, zanim to będzie mogło się uruchomić. Przycisk uruchamiania pozostaje zablokowany, dopóki wszystkie zależności nie będą gotowe.",
@@ -4703,6 +4709,11 @@
         "title": "Brak kryteriów sukcesu",
         "hint": "Podaj pytanie, na które odpowiada spike, albo jak wygląda dobry wynik, żeby wyznaczony czas miał cel."
       },
+      "required_field_missing": {
+        "title": "Brakuje: {field}",
+        "hint": "Ten typ zadania wymaga pola „{field}”, a zadanie go nie wypełnia. Uzupełnij je w zadaniu i sprawdź ponownie.",
+        "unnamedField": "pole wymagane"
+      },
       "unknown": {
         "title": "Nierozpoznane ustalenie",
         "hint": "Ten przebieg zapisał kontrolę, której ta wersja już nie zna. Przejrzyj zadanie ręcznie przed kontynuowaniem."
@@ -5359,6 +5370,7 @@
     "operation": {
       "provision": "Uruchom",
       "teardown": "Zatrzymaj",
+      "teardown-verify": "Sprawdzenie zatrzymania",
       "status": "Sprawdzenie stanu",
       "dispatch": "Uruchom",
       "release": "Zatrzymaj",

package/i18n/locales/tr.json

@@ -1003,6 +1003,12 @@
       "inherited": "hizmetten devralındı",
       "frozen": "Donduruldu: ajan başladı"
     },
+    "taskTypeFields": {
+      "title": "Görev türü alanları",
+      "hint": "Bu görev türünün gerekli olduğunu bildirdiği yanıtlar. Eksik bir zorunlu yanıt, çalıştırmayı başlamadan önce duraklatır.",
+      "save": "Kaydet",
+      "revert": "Geri al"
+    },
     "dependencies": {
       "title": "Şuna bağlı",
       "hint": "Bu görev çalışmadan önce birleştirilmesi gereken görevler. Tüm bağımlılıklar tamamlanana kadar Çalıştır kontrolü kilitli kalır.",
@@ -4703,6 +4709,11 @@
         "title": "Başarı ölçütü yok",
         "hint": "Spike'ın yanıtladığı soruyu ya da iyi bir sonucun neye benzediğini yazın ki ayrılan sürenin bir hedefi olsun."
       },
+      "required_field_missing": {
+        "title": "Eksik: {field}",
+        "hint": "Bu görev türü “{field}” alanını zorunlu kılıyor, ancak görevde doldurulmamış. Görevde doldurup yeniden denetleyin.",
+        "unnamedField": "zorunlu bir alan"
+      },
       "unknown": {
         "title": "Tanınmayan bulgu",
         "hint": "Bu çalışma, bu sürümün artık bilmediği bir denetimi kaydetmiş. Devam etmeden önce görevi elle gözden geçirin."
@@ -5359,6 +5370,7 @@
     "operation": {
       "provision": "Başlat",
       "teardown": "Kapat",
+      "teardown-verify": "Kapatma kontrolü",
       "status": "Durum kontrolü",
       "dispatch": "Başlat",
       "release": "Kapat",

package/i18n/locales/uk.json

@@ -1003,6 +1003,12 @@
       "inherited": "успадковано від сервісу",
       "frozen": "Заморожено: агент уже стартував"
     },
+    "taskTypeFields": {
+      "title": "Поля типу завдання",
+      "hint": "Відповіді, які потрібні цьому типу завдання. Відсутня обов'язкова відповідь зупиняє запуск до його початку.",
+      "save": "Зберегти",
+      "revert": "Скасувати зміни"
+    },
     "dependencies": {
       "title": "Залежить від",
       "hint": "Завдання, які мають бути злиті, перш ніж це зможе запуститися. Кнопка запуску лишається заблокованою, доки всі залежності не виконано.",
@@ -4703,6 +4709,11 @@
         "title": "Немає критеріїв успіху",
         "hint": "Вкажіть питання, на яке відповідає spike, або який результат є добрим, щоб відведений час мав ціль."
       },
+      "required_field_missing": {
+        "title": "Бракує: {field}",
+        "hint": "Цей тип завдання вимагає «{field}», але завдання його не заповнює. Заповніть його в завданні й перевірте ще раз.",
+        "unnamedField": "обов'язкове поле"
+      },
       "unknown": {
         "title": "Нерозпізнаний висновок",
         "hint": "Цей запуск зафіксував перевірку, якої ця версія вже не знає. Перегляньте завдання вручну, перш ніж продовжувати."
@@ -5359,6 +5370,7 @@
     "operation": {
       "provision": "Запустити",
       "teardown": "Згорнути",
+      "teardown-verify": "Перевірка згортання",
       "status": "Перевірка стану",
       "dispatch": "Запустити",
       "release": "Згорнути",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cat-factory/app",
-  "version": "0.223.0",
+  "version": "0.224.0",
   "description": "Reusable Nuxt layer for the Agent Architecture Board SPA (components, stores, composables, pages). Consume it from a thin deployment app via `extends: ['@cat-factory/app']` and point it at your backend with NUXT_PUBLIC_API_BASE. See deploy/frontend for an example.",
   "repository": {
     "type": "git",
@@ -40,7 +40,7 @@
     "valibot": "^1.4.2",
     "vue": "3.5.40",
     "wretch": "^3.0.9",
-    "@cat-factory/contracts": "0.239.0"
+    "@cat-factory/contracts": "0.240.0"
   },
   "devDependencies": {
     "@toad-contracts/testing": "0.3.2",