@cat-factory/app 0.272.0 → 0.273.1

package/app/components/environments/EnvironmentStatusPanel.vue

@@ -6,7 +6,18 @@
 import type { InfraEngine, ProvisionType } from '@cat-factory/contracts'
 import type { RunEnvironment, HumanTestEnvironmentStatus } from '~/types/execution'
 
-const props = defineProps<{ environment: RunEnvironment | null; degradedReason?: string | null }>()
+const props = defineProps<{
+  environment: RunEnvironment | null
+  /**
+   * Whether the enclosing run is still being driven (`runIsActive`). A transitional status
+   * (`provisioning` / `tearing_down`) keeps its label once the run stops, because that is the
+   * last thing the provider reported, but its icon stops spinning: nothing is standing this
+   * environment up any more. Required rather than defaulted so a new call site has to say which
+   * run it is rendering, instead of silently inheriting a perpetual spinner.
+   */
+  runActive: boolean
+  degradedReason?: string | null
+}>()
 
 const { t, d } = useI18n()
 
@@ -74,6 +85,13 @@ const ENV_STATUS_META = computed<
     icon: 'i-lucide-circle-off',
   },
 }))
+
+// The two statuses that describe a transition IN FLIGHT. Only these ever animate, and only
+// while the run driving the transition is still being driven itself.
+const envInTransition = computed(
+  () =>
+    props.environment?.status === 'provisioning' || props.environment?.status === 'tearing_down',
+)
 </script>
 
 <template>
@@ -88,10 +106,7 @@ const ENV_STATUS_META = computed<
           class="h-3.5 w-3.5"
           :class="[
             ENV_STATUS_META[environment.status].color,
-            {
-              'animate-spin':
-                environment.status === 'provisioning' || environment.status === 'tearing_down',
-            },
+            { 'animate-spin': runActive && envInTransition },
           ]"
         />
         <span :class="ENV_STATUS_META[environment.status].color">{{

package/app/components/panels/AgentStepDetail.vue

@@ -25,6 +25,7 @@ import {
   REDIRECT_PARK_PRESENTATION,
   type RedirectParkView,
   dedicatedParkView,
+  runIsActive,
 } from '~/utils/pipelineRender'
 import InputGateNotice from '~/components/inputGate/InputGateNotice.vue'
 
@@ -125,13 +126,12 @@ const showHistory = ref(false)
 // "spinning up" phase, no spinner.
 const runFailed = computed(() => instance.value?.status === 'failed')
 
-// Whether the run is still doing something (can still spin infra up/down). A terminal
-// run (`done`/`failed`) has nothing left to provision, so the infra-attempts drawer
-// stops its background live-polling (manual refresh stays available).
-const runLive = computed(() => {
-  const status = instance.value?.status
-  return status != null && status !== 'done' && status !== 'failed'
-})
+// Whether the engine is still driving this run, and so can still spin infrastructure up or down.
+// One shared predicate drives every infra surface below: the attempts drawer's background poll
+// (manual refresh stays available regardless), the container card's cold-boot spinner, and the
+// environment panel's transition spinner. A run that is terminal OR parked has nothing in flight,
+// so none of those may keep animating.
+const runActive = computed(() => runIsActive(instance.value?.status))
 
 // Live elapsed-time clock for the open step.
 const { isRunning, durationLabel } = useStepTimer({
@@ -497,6 +497,7 @@ async function copyOutput() {
                 <StepMetadataCard
                   :step="step"
                   :run-failed="runFailed"
+                  :run-active="runActive"
                   :duration-label="durationLabel"
                   :is-running="isRunning"
                   :step-number="stepNumber"
@@ -592,7 +593,11 @@ async function copyOutput() {
 
               <!-- ephemeral environment lifecycle (spinning up / running / shut down /
                    errored + the exact error), when this step runs against one -->
-              <EnvironmentStatusPanel v-if="stepEnvironment" :environment="stepEnvironment" />
+              <EnvironmentStatusPanel
+                v-if="stepEnvironment"
+                :environment="stepEnvironment"
+                :run-active="runActive"
+              />
 
               <!-- frontend UI-test: how the frame's backend bindings resolved (env var →
                    live URL | mocked) + the run-start advisories (duplicate env vars /
@@ -639,7 +644,7 @@ async function copyOutput() {
                   v-if="showProvisioning"
                   class="mt-2"
                   :execution-id="executionId"
-                  :live="runLive"
+                  :live="runActive"
                 />
               </div>
 

package/app/components/panels/StepContainerStatus.vue

@@ -8,7 +8,18 @@ import { containerPhaseLabel } from '~/utils/pipelineRender'
 // making calls), and the container's id + reachable URL once up. Shared by the generic
 // step detail (StepMetadataCard) and the dedicated Tester window so both surface WHAT the
 // container is doing and WHERE it lives instead of a bare "working" — identical parity.
-const props = defineProps<{ step: PipelineStep; runFailed: boolean }>()
+const props = defineProps<{
+  step: PipelineStep
+  runFailed: boolean
+  /**
+   * Whether the enclosing run is still being driven (`runIsActive`). Distinct from
+   * {@link runFailed}, which answers whether the container was RECLAIMED: a run parked on a
+   * human decision or a spend budget has reclaimed nothing, so its container keeps whatever
+   * status it stopped at. A `starting` one is no longer cold-booting, though, so it must not
+   * keep spinning as though it were.
+   */
+  runActive: boolean
+}>()
 
 const { t, te } = useI18n()
 
@@ -59,6 +70,14 @@ const CONTAINER_STATUS_META: Record<
   },
 }
 
+// Whether the status icon animates: only a cold-boot genuinely in flight, i.e. one whose run is
+// still being driven. A `starting` container on a parked or terminated run keeps its label and
+// freezes, the same way a mid-flight subtask item does (`subtaskIconClass`).
+const spinIcon = computed(
+  () =>
+    props.runActive && !!containerStatus.value && CONTAINER_STATUS_META[containerStatus.value].spin,
+)
+
 // The friendly phase label (clone → "Preparing workspace", …); only meaningful while up.
 const phaseLabel = computed(() => containerPhaseLabel(props.step.container?.phase, { t, te }))
 
@@ -82,7 +101,7 @@ const { copy: copyText } = useCopyToClipboard()
         <UIcon
           :name="CONTAINER_STATUS_META[containerStatus].icon"
           class="h-4 w-4 shrink-0"
-          :class="CONTAINER_STATUS_META[containerStatus].spin ? 'animate-spin' : ''"
+          :class="spinIcon ? 'animate-spin' : ''"
         />
         <span class="font-medium">{{ t(CONTAINER_STATUS_KEYS[containerStatus]) }}</span>
         <template v-if="phaseLabel && containerStatus === 'up'">

package/app/components/panels/StepMetadataCard.vue

@@ -20,6 +20,8 @@ import MarkdownProse from '~/components/common/MarkdownProse.vue'
 const props = defineProps<{
   step: PipelineStep
   runFailed: boolean
+  /** Whether the run is still being driven; passed through so its container card can freeze. */
+  runActive: boolean
   durationLabel: string | null
   isRunning: boolean
   stepNumber: number
@@ -246,7 +248,12 @@ async function copyRunId() {
 
     <!-- container lifecycle (status / live phase / id + url) — shared with the Tester
          window so both surface what the container is doing and where it lives. -->
-    <StepContainerStatus :step="step" :run-failed="runFailed" class="mt-4" />
+    <StepContainerStatus
+      :step="step"
+      :run-failed="runFailed"
+      :run-active="runActive"
+      class="mt-4"
+    />
 
     <!-- live subtask breakdown -->
     <div v-if="step.subtasks && step.subtasks.total > 0" class="mt-4">

package/app/components/provisioning/ProvisioningLogsDrawer.vue

@@ -6,13 +6,16 @@
 // panels' drawer, or `executionId` for a run's "Infrastructure attempts" drawer (which
 // surfaces that run's container/runner/env attempts).
 //
-// In `executionId` mode the drawer LIVE-tracks: while the run is active (`live`) it
-// silently re-polls so each container spin-up / tear-down appears with its timestamp as
-// it happens, and it does one final poll when the run goes terminal to catch the last
-// tear-down row (written just before the terminal event), after which the auto-poll
-// stops. Background polls never spin the refresh button (they're silent), but the manual
-// refresh control stays available even once the run is terminal — so a tear-down row that
-// was missed or not yet persisted at the terminal instant can always be refetched.
+// In `executionId` mode the drawer LIVE-tracks: while the engine is driving the run (`live`,
+// from `runIsActive`) it silently re-polls so each container spin-up / tear-down appears with
+// its timestamp as it happens, and it does one final poll when the run stops being driven, to
+// catch the last tear-down row (written just before the terminal event), after which the
+// auto-poll stops. "Stops being driven" covers a PARK as well as a terminal state: a run waiting
+// on a human decision or a raised spend budget writes no further attempts until it resumes, and
+// the same watch restarts the poll when it does. Background polls never spin the refresh button
+// (they're silent), but the manual refresh control stays available even once the run is terminal,
+// so a tear-down row that was missed or not yet persisted at the terminal instant can always be
+// refetched.
 import { onBeforeUnmount, onMounted, watch } from 'vue'
 import type {
   ProvisioningOperation,
@@ -23,7 +26,10 @@ import type {
 const props = defineProps<{
   subsystem?: ProvisioningSubsystem
   executionId?: string
-  /** Run-details mode only: whether the run is still active (drives live polling). */
+  /**
+   * Run-details mode only: whether the engine is still driving the run (`runIsActive`), which
+   * drives the background poll. A terminal OR parked run writes no further attempts.
+   */
   live?: boolean
 }>()
 
@@ -68,8 +74,8 @@ watch(
     // clears, `live` and `executionId` fall away in the same tick, so stop the interval
     // unconditionally or it leaks (firing no-op reloads) for the component's lifetime.
     stopPolling()
-    // On the active→terminal transition, poll once more (silently) to pick up the
-    // tear-down row the engine writes just before it emits the terminal state.
+    // On the active→stopped transition (parked or terminal), poll once more (silently) to pick
+    // up the tear-down row the engine writes just before it emits that state.
     if (wasLive && props.executionId != null) reload(true)
   },
   { immediate: true },

package/app/components/testing/TestReportWindow.vue

@@ -21,6 +21,7 @@ import AttemptEntryHeader from '~/components/panels/AttemptEntryHeader.vue'
 import EnvironmentStatusPanel from '~/components/environments/EnvironmentStatusPanel.vue'
 import ProvisioningLogsDrawer from '~/components/provisioning/ProvisioningLogsDrawer.vue'
 import MarkdownProse from '~/components/common/MarkdownProse.vue'
+import { runIsActive } from '~/utils/pipelineRender'
 
 const board = useBoardStore()
 const execution = useExecutionStore()
@@ -65,12 +66,10 @@ const qualityVerdicts = computed(() => [...(quality.value?.verdicts ?? [])].reve
 // run's infrastructure attempts + logs (container/runner/env spin-up), not just the
 // report. The container/subtask signals already flow onto the step via the generic poll.
 const runFailed = computed(() => instance.value?.status === 'failed')
-// A terminal run (done/failed) can't spin more infra: the attempts drawer stops its
-// background live-polling (manual refresh stays available).
-const runLive = computed(() => {
-  const status = instance.value?.status
-  return status != null && status !== 'done' && status !== 'failed'
-})
+// Whether the engine is still driving this run. A run that is terminal OR parked can't spin more
+// infra, so the attempts drawer stops its background poll (manual refresh stays available) and
+// neither the container card nor the environment panel keeps animating over it.
+const runActive = computed(() => runIsActive(instance.value?.status))
 const stepEnvironment = computed(() => step.value?.environment ?? null)
 const executionId = computed(() => instance.value?.id ?? null)
 // The infra-attempts log drawer is opened on demand (it fetches the per-run log rows).
@@ -355,8 +354,12 @@ const GROUP_STATUS_META: Record<ScenarioGroup['status'], { icon: string; text: s
           <h3 class="text-[11px] font-semibold uppercase tracking-wide text-slate-500">
             {{ t('testing.infrastructure') }}
           </h3>
-          <StepContainerStatus :step="step" :run-failed="runFailed" />
-          <EnvironmentStatusPanel v-if="stepEnvironment" :environment="stepEnvironment" />
+          <StepContainerStatus :step="step" :run-failed="runFailed" :run-active="runActive" />
+          <EnvironmentStatusPanel
+            v-if="stepEnvironment"
+            :environment="stepEnvironment"
+            :run-active="runActive"
+          />
 
           <!-- In-container docker-compose dependency stand-up (local-infra tester): the
                    outcome + the captured `docker compose up` logs. This is the stand-up that
@@ -459,7 +462,7 @@ const GROUP_STATUS_META: Record<ScenarioGroup['status'], { icon: string; text: s
               v-if="showProvisioning"
               class="mt-2"
               :execution-id="executionId"
-              :live="runLive"
+              :live="runActive"
             />
           </div>
         </section>

package/app/types/execution.ts

@@ -115,6 +115,7 @@ export type {
   VisualConfirmDesignReferences,
   VisualConfirmRound,
   ExecutionInstance,
+  ExecutionStatus,
   // The historical frontend name for a per-block review comment is the contract's
   // StepReviewComment; the env-status union is the contract's EnvironmentStatus.
   StepReviewComment as ReviewComment,

package/app/utils/failureKinds.ts

@@ -26,6 +26,7 @@ export const FAILURE_KIND_KEYS: Record<AgentFailureKind, string> = {
   dispatch: 'platformObservability.failureKind.dispatch',
   environment: 'platformObservability.failureKind.environment',
   evicted: 'platformObservability.failureKind.evicted',
+  harness_shutdown: 'platformObservability.failureKind.harness_shutdown',
   timeout: 'platformObservability.failureKind.timeout',
   agent: 'platformObservability.failureKind.agent',
   job_failed: 'platformObservability.failureKind.job_failed',

package/app/utils/pipelineRender.spec.ts

@@ -1,8 +1,17 @@
 import { describe, it, expect } from 'vitest'
-import { binaryCandidateStatusSchema, stepSkipReasonSchema } from '@cat-factory/contracts'
+import {
+  binaryCandidateStatusSchema,
+  executionStatusSchema,
+  stepSkipReasonSchema,
+} from '@cat-factory/contracts'
 import type { ExecutionInstance, PipelineStep } from '~/types/execution'
 import { missingI18nKeys } from '../../test/i18nKeys'
-import { REDIRECT_PARK_PRESENTATION, dedicatedParkView, stepSkipReasonKey } from './pipelineRender'
+import {
+  REDIRECT_PARK_PRESENTATION,
+  dedicatedParkView,
+  runIsActive,
+  stepSkipReasonKey,
+} from './pipelineRender'
 
 /** A minimal coder step; the predicate only reads approval/followUps/forkDecision. */
 const step = (over: Partial<PipelineStep>): PipelineStep =>
@@ -229,3 +238,29 @@ describe('stepSkipReasonKey', () => {
     expect(missingI18nKeys([...keys, 'pipeline.progress.skipped.unknown'])).toEqual([])
   })
 })
+
+describe('runIsActive', () => {
+  it('answers true for exactly the one status the engine is driving under', () => {
+    // Derived from the vocabulary the engine writes, not a hand-listed set: a status added to the
+    // picklist fails here until someone decides whether infrastructure can move under it. That
+    // decision is what every animated infra indicator is gated on, so defaulting a new member
+    // either way silently is the failure this pins.
+    expect(executionStatusSchema.options.filter(runIsActive)).toEqual(['running'])
+  })
+
+  it('treats a PARK as inactive, not only a terminal state', () => {
+    // The distinction that makes this more than `status !== 'done' && status !== 'failed'`: a run
+    // waiting on a human decision (`blocked`) or on a raised spend budget (`paused`) is asleep in
+    // the durable driver. Nothing is cold-booting or being torn down under it, so a container left
+    // `starting` or an environment left `provisioning` must stop claiming otherwise.
+    expect(runIsActive('blocked')).toBe(false)
+    expect(runIsActive('paused')).toBe(false)
+  })
+
+  it('answers false when the run has no status to read', () => {
+    // The overlays render before/after their run resolves, and an unknown run is not a running
+    // one: the indicator must start still and begin turning once the run says it is being driven.
+    expect(runIsActive(null)).toBe(false)
+    expect(runIsActive(undefined)).toBe(false)
+  })
+})

package/app/utils/pipelineRender.ts

@@ -2,9 +2,38 @@
 // 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, ExecutionInstance, PipelineStep } from '~/types/execution'
+import type {
+  AgentState,
+  ExecutionInstance,
+  ExecutionStatus,
+  PipelineStep,
+} from '~/types/execution'
 import { isStepSkipReason } from '@cat-factory/contracts'
 
+/**
+ * Whether the engine is presently DRIVING this run, which is the one condition under which
+ * infrastructure can still be moving (a container cold-booting, an environment coming up or
+ * being torn down, a fresh provisioning attempt landing in the log).
+ *
+ * `running` is that condition and nothing else is. `done`/`failed` are terminal, and the other
+ * two are parks where the durable driver is asleep on an event: `blocked` waits on a human
+ * decision, `paused` on a spend budget that has to be raised. A parked run holds whatever infra
+ * state it stopped at, so nothing about it is in flight.
+ *
+ * This is what every ANIMATED infra indicator is gated on. A spinner is a claim that something is
+ * happening right now, so a container left `starting` or an environment left `provisioning` when
+ * its run stopped must keep its label (that IS the last thing the provider reported) and stop
+ * turning: the run's own status says why it stopped, and a perpetual spinner over a run nobody is
+ * driving reads as a live cold-boot that is simply taking a while. The same rule governs the
+ * infra-attempts drawer's background poll, which has nothing to re-read off a parked run.
+ *
+ * The step-level sibling is `stepIsRunning` (`useStepTimer`), which answers the narrower question
+ * of whether one step's clock should tick; this one is about the run as a whole.
+ */
+export function runIsActive(status: ExecutionStatus | null | undefined): boolean {
+  return status === 'running'
+}
+
 /**
  * Visual state of a conditionally-run companion attached to a gate step (today the
  * Tester's `fixer`): it MIGHT run (`possible`), is running now (`running`), ran at

package/i18n/locales/de.json

@@ -3848,6 +3848,7 @@
       "dispatch": "Zustellung",
       "environment": "Umgebung",
       "evicted": "Verdrängt",
+      "harness_shutdown": "Harness beendet",
       "timeout": "Zeitüberschreitung",
       "agent": "Agent",
       "job_failed": "Job fehlgeschlagen",

package/i18n/locales/en.json

@@ -1892,6 +1892,7 @@
       "dispatch": "Dispatch",
       "environment": "Environment",
       "evicted": "Evicted",
+      "harness_shutdown": "Harness shut down",
       "timeout": "Timeout",
       "agent": "Agent",
       "job_failed": "Job failed",

package/i18n/locales/es.json

@@ -1794,6 +1794,7 @@
       "dispatch": "Despacho",
       "environment": "Entorno",
       "evicted": "Desalojada",
+      "harness_shutdown": "Harness detenido",
       "timeout": "Tiempo agotado",
       "agent": "Agente",
       "job_failed": "Trabajo fallido",

package/i18n/locales/fr.json

@@ -1794,6 +1794,7 @@
       "dispatch": "Envoi",
       "environment": "Environnement",
       "evicted": "Évincée",
+      "harness_shutdown": "Harness arrêté",
       "timeout": "Délai dépassé",
       "agent": "Agent",
       "job_failed": "Tâche échouée",

package/i18n/locales/he.json

@@ -1794,6 +1794,7 @@
       "dispatch": "שיגור",
       "environment": "סביבה",
       "evicted": "פונתה",
+      "harness_shutdown": "כיבוי ה-Harness",
       "timeout": "פסק זמן",
       "agent": "סוכן",
       "job_failed": "המשימה נכשלה",

package/i18n/locales/it.json

@@ -3848,6 +3848,7 @@
       "dispatch": "Invio",
       "environment": "Ambiente",
       "evicted": "Sfrattata",
+      "harness_shutdown": "Harness arrestato",
       "timeout": "Timeout",
       "agent": "Agente",
       "job_failed": "Job fallito",

package/i18n/locales/ja.json

@@ -1794,6 +1794,7 @@
       "dispatch": "ディスパッチ",
       "environment": "環境",
       "evicted": "退避",
+      "harness_shutdown": "Harness 停止",
       "timeout": "タイムアウト",
       "agent": "エージェント",
       "job_failed": "ジョブ失敗",

package/i18n/locales/pl.json

@@ -1794,6 +1794,7 @@
       "dispatch": "Wysłanie",
       "environment": "Środowisko",
       "evicted": "Usunięte",
+      "harness_shutdown": "Harness zatrzymany",
       "timeout": "Przekroczono czas",
       "agent": "Agent",
       "job_failed": "Zadanie nieudane",

package/i18n/locales/tr.json

@@ -1794,6 +1794,7 @@
       "dispatch": "Gönderim",
       "environment": "Ortam",
       "evicted": "Tahliye edildi",
+      "harness_shutdown": "Harness kapatıldı",
       "timeout": "Zaman aşımı",
       "agent": "Aracı",
       "job_failed": "İş başarısız",

package/i18n/locales/uk.json

@@ -1794,6 +1794,7 @@
       "dispatch": "Відправлення",
       "environment": "Середовище",
       "evicted": "Витіснено",
+      "harness_shutdown": "Harness зупинено",
       "timeout": "Час вичерпано",
       "agent": "Агент",
       "job_failed": "Завдання не виконано",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cat-factory/app",
-  "version": "0.272.0",
+  "version": "0.273.1",
   "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.41",
     "wretch": "^3.0.9",
-    "@cat-factory/contracts": "0.311.0"
+    "@cat-factory/contracts": "0.312.0"
   },
   "devDependencies": {
     "@toad-contracts/testing": "0.3.2",