@cat-factory/app 0.115.0 → 0.115.2

package/app/components/board/AgentStopButton.vue

@@ -22,12 +22,23 @@ const props = withDefaults(
 const { t } = useI18n()
 const agentRuns = useAgentRunsStore()
 const toast = useToast()
+const { confirm } = useConfirm()
 const stopping = ref(false)
 
 const displayLabel = computed(() => props.label ?? t('board.stop.label'))
 
 async function stop() {
   if (stopping.value) return
+  // Killing a running container discards its in-flight work — gate it behind a confirm,
+  // matching the confirm-then-mutate contract the task reset path uses.
+  const ok = await confirm({
+    title: t('board.stop.confirm.title'),
+    description: t('board.stop.confirm.body'),
+    confirmLabel: t('board.stop.confirm.confirm'),
+    variant: 'destructive',
+    icon: 'i-lucide-circle-stop',
+  })
+  if (!ok) return
   stopping.value = true
   try {
     const kind = await agentRuns.stop(props.runId)

package/app/components/panels/InspectorPanel.vue

@@ -100,6 +100,21 @@ const statusLabel = computed(() =>
 
 const runnable = computed(() => (block.value ? board.isRunnable(block.value.id) : false))
 
+// A task runs only once every dependency has merged. When the Run trigger is locked
+// it must say WHY — name the unfinished dependencies rather than showing a bare lock.
+const unmetDepTitles = computed(() =>
+  block.value && isTask.value ? board.unmetDeps(block.value.id).map((b) => b.title) : [],
+)
+const runBlockedReason = computed(() =>
+  unmetDepTitles.value.length
+    ? t(
+        'panels.inspector.runBlocked',
+        { count: unmetDepTitles.value.length, names: unmetDepTitles.value.join(', ') },
+        unmetDepTitles.value.length,
+      )
+    : null,
+)
+
 // The delete control names what it removes, so selecting a task and deleting it
 // reads as "Delete task" rather than ambiguously removing the whole service.
 const deleteLabel = computed(() =>
@@ -532,6 +547,19 @@ const showOriginalDescription = ref(false)
       <!-- initiative: status + goal, run-planning + tracker controls -->
       <InitiativeInspector v-else-if="isInitiative" :block="block" />
 
+      <!-- Locked-run explanation: a disabled task Run button reads as a dead lock unless
+           it says what's holding it. Named here (and on the button title) so the blocking
+           dependencies are visible to pointer, keyboard, and touch alike — a native title
+           on a disabled button doesn't fire hover events. -->
+      <p
+        v-if="isTask && runBlockedReason"
+        class="flex items-start gap-1.5 text-[11px] text-amber-300/90"
+        data-testid="run-blocked-reason"
+      >
+        <UIcon name="i-lucide-lock" class="mt-px h-3 w-3 shrink-0" />
+        <span>{{ runBlockedReason }}</span>
+      </p>
+
       <!-- actions -->
       <div class="flex items-center gap-2">
         <UDropdownMenu v-if="isTask" :items="runMenu">
@@ -542,6 +570,7 @@ const showOriginalDescription = ref(false)
             :icon="runnable ? 'i-lucide-play' : 'i-lucide-lock'"
             trailing-icon="i-lucide-chevron-down"
             :disabled="!runnable"
+            :title="runBlockedReason ?? undefined"
           >
             {{ instance ? t('panels.inspector.reRun') : t('panels.inspector.run') }}
           </UButton>

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

@@ -11,6 +11,8 @@ import AgentFailureCard from '~/components/board/AgentFailureCard.vue'
 import AgentFailureHistory from '~/components/board/AgentFailureHistory.vue'
 import EmptyState from '~/components/common/EmptyState.vue'
 import InspectorSection from '~/components/panels/inspector/InspectorSection.vue'
+import { useNowTick, stepDurationLabel } from '~/composables/useStepTimer'
+import type { PipelineStep } from '~/types/execution'
 
 const props = defineProps<{ block: Block }>()
 
@@ -85,6 +87,13 @@ function stepFailed(s: { state: string }) {
   return runFailed.value && s.state === 'working'
 }
 
+// A shared 1s tick drives every step's live elapsed clock, so a running step that
+// hasn't yet emitted subtask counts reads as progressing rather than hung.
+const nowTick = useNowTick()
+function stepElapsed(s: PipelineStep): string | null {
+  return stepDurationLabel(s, nowTick.value, runFailed.value, instance.value?.failure?.occurredAt)
+}
+
 /** A gated step parked for approval reads "Needs approval", not "Needs decision". */
 function labelForStep(s: {
   state: string
@@ -148,6 +157,17 @@ function openForkFor(i: number) {
 const stopping = ref(false)
 async function stopRun() {
   if (!instance.value || stopping.value) return
+  // Killing the running container discards its in-flight work — gate it behind the same
+  // confirm the board card's stop uses (via `AgentStopButton`), so every stop surface for
+  // a run is confirm-gated identically.
+  const ok = await confirm({
+    title: t('board.stop.confirm.title'),
+    description: t('board.stop.confirm.body'),
+    confirmLabel: t('board.stop.confirm.confirm'),
+    variant: 'destructive',
+    icon: 'i-lucide-circle-stop',
+  })
+  if (!ok) return
   stopping.value = true
   try {
     await execution.stop(instance.value.id)
@@ -306,6 +326,14 @@ async function mergePr() {
             >
               <UIcon v-if="stepFailed(s)" name="i-lucide-circle-x" class="h-3 w-3 shrink-0" />
               {{ labelForStep(s) }}
+              <!-- live elapsed clock: a running step counts up, a finished one shows total -->
+              <span
+                v-if="stepElapsed(s)"
+                class="inline-flex items-center gap-0.5 font-mono tabular-nums text-slate-500"
+                :title="t('inspector.execution.elapsedTooltip')"
+              >
+                · {{ stepElapsed(s) }}
+              </span>
             </span>
             <UButton
               v-if="s.decision && !s.decision.chosen"

package/app/components/pipeline/PipelineProgress.vue

@@ -12,6 +12,7 @@ import {
   containerPhaseLabel,
 } from '~/utils/pipelineRender'
 import StepMetricsBar from '~/components/observability/StepMetricsBar.vue'
+import { useNowTick, stepDurationLabel } from '~/composables/useStepTimer'
 
 const props = defineProps<{ instance: ExecutionInstance }>()
 const emit = defineEmits<{
@@ -136,6 +137,13 @@ const STATUS_META = computed<Record<ExecutionInstance['status'], { label: string
 const steps = computed(() => props.instance.steps)
 const total = computed(() => steps.value.length)
 
+// A shared 1s tick drives every step's live elapsed clock, so a step that hasn't yet
+// emitted subtask counts still shows it is progressing rather than reading as hung.
+const nowTick = useNowTick()
+function stepElapsed(s: PipelineStep): string | null {
+  return stepDurationLabel(s, nowTick.value, runFailed.value, props.instance.failure?.occurredAt)
+}
+
 // The conditionally-run companion (e.g. the Tester's `fixer`) each step drives, with
 // its possible/running/completed/skipped state — rendered as a distinct sub-node so a
 // human can see at a glance whether the fixer ran or was skipped.
@@ -322,8 +330,20 @@ const ITEM_ICON: Record<string, string> = {
                   {{ t('pipeline.progress.companion') }}
                 </span>
               </div>
-              <div class="text-[10px] uppercase tracking-wide text-slate-500">
-                {{ t('pipeline.progress.stepOf', { current: i + 1, total }) }}
+              <div
+                class="flex items-center gap-1.5 text-[10px] uppercase tracking-wide text-slate-500"
+              >
+                <span>{{ t('pipeline.progress.stepOf', { current: i + 1, total }) }}</span>
+                <!-- live elapsed clock: a running step counts up (so no-subtask steps
+                     don't read as hung), a finished step shows its total duration -->
+                <span
+                  v-if="stepElapsed(s)"
+                  class="inline-flex items-center gap-0.5 font-mono normal-case tabular-nums text-slate-400"
+                  :title="t('pipeline.progress.elapsedTooltip')"
+                >
+                  <UIcon name="i-lucide-clock" class="h-2.5 w-2.5 shrink-0" />
+                  {{ stepElapsed(s) }}
+                </span>
               </div>
             </div>
             <span
@@ -343,7 +363,7 @@ const ITEM_ICON: Record<string, string> = {
                 color="neutral"
                 variant="ghost"
                 size="xs"
-                class="shrink-0 opacity-0 transition-opacity group-hover:opacity-100"
+                class="shrink-0 opacity-0 transition-opacity group-hover:opacity-100 group-focus-within:opacity-100 focus-visible:opacity-100"
                 :title="t('pipeline.progress.restartTooltip')"
                 @click.stop="
                   () => {

package/app/components/provisioning/ProvisioningLogsDrawer.vue

@@ -76,7 +76,12 @@ watch(
 )
 
 onMounted(() => reload())
-onBeforeUnmount(stopPolling)
+onBeforeUnmount(() => {
+  stopPolling()
+  // Drop this run's accumulated log state so the per-execution map doesn't grow for the app's
+  // lifetime (a re-opened drawer re-fetches on mount). Subsystem mode keeps its fixed-size state.
+  if (props.executionId) store.evict(props.executionId)
+})
 
 // Exhaustive enum→label maps of literal `t(...)` keys (keeps the typed-key drift guard
 // live for these runtime-indexed lookups).

package/app/composables/useStepTimer.spec.ts

@@ -0,0 +1,80 @@
+import { describe, expect, it } from 'vitest'
+import type { PipelineStep } from '~/types/execution'
+import { stepDurationLabel, stepDurationMs, stepIsRunning } from '~/composables/useStepTimer'
+
+// The pure helpers encode one freeze rule shared by the list surfaces (pipeline timeline,
+// inspector run list) and the single-step overlay, so pin the precedence here:
+// finishedAt > (runFailed ? failureAt ?? startedAt) > pausedAt > live now.
+function step(overrides: Partial<PipelineStep> = {}): PipelineStep {
+  return { agentKind: 'coder', state: 'working', ...overrides } as PipelineStep
+}
+
+const NOW = 10_000
+
+describe('stepIsRunning', () => {
+  it('is false for a null step', () => {
+    expect(stepIsRunning(null, false)).toBe(false)
+  })
+
+  it('is false until the step has started', () => {
+    expect(stepIsRunning(step({ startedAt: undefined }), false)).toBe(false)
+  })
+
+  it('is true for a started, unfinished, unparked step on a live run', () => {
+    expect(stepIsRunning(step({ startedAt: 1000 }), false)).toBe(true)
+  })
+
+  it('is false once finished, parked, or the run failed', () => {
+    expect(stepIsRunning(step({ startedAt: 1000, finishedAt: 2000 }), false)).toBe(false)
+    expect(stepIsRunning(step({ startedAt: 1000, pausedAt: 1500 }), false)).toBe(false)
+    expect(stepIsRunning(step({ startedAt: 1000 }), true)).toBe(false)
+  })
+})
+
+describe('stepDurationMs', () => {
+  it('is null until the step has started', () => {
+    expect(stepDurationMs(step({ startedAt: undefined }), NOW, false, null)).toBeNull()
+    expect(stepDurationMs(null, NOW, false, null)).toBeNull()
+  })
+
+  it('counts up to now while live', () => {
+    expect(stepDurationMs(step({ startedAt: 4000 }), NOW, false, null)).toBe(6000)
+  })
+
+  it('freezes at finishedAt once finished (ignoring now)', () => {
+    expect(stepDurationMs(step({ startedAt: 4000, finishedAt: 7000 }), NOW, false, null)).toBe(3000)
+  })
+
+  it('freezes at the run failure time when the run failed', () => {
+    expect(stepDurationMs(step({ startedAt: 4000 }), NOW, true, 6000)).toBe(2000)
+  })
+
+  it('falls back to startedAt (zero) when the run failed with no failure time', () => {
+    expect(stepDurationMs(step({ startedAt: 4000 }), NOW, true, null)).toBe(0)
+  })
+
+  it('freezes at the park time when parked on a human', () => {
+    expect(stepDurationMs(step({ startedAt: 4000, pausedAt: 5500 }), NOW, false, null)).toBe(1500)
+  })
+
+  it('prefers finishedAt over the failure time', () => {
+    expect(stepDurationMs(step({ startedAt: 4000, finishedAt: 5000 }), NOW, true, 6000)).toBe(1000)
+  })
+
+  it('never returns a negative duration', () => {
+    expect(stepDurationMs(step({ startedAt: 8000 }), NOW, true, 6000)).toBe(0)
+  })
+})
+
+describe('stepDurationLabel', () => {
+  it('is null until the step has started', () => {
+    expect(stepDurationLabel(step({ startedAt: undefined }), NOW, false, null)).toBeNull()
+  })
+
+  it('formats seconds and minutes', () => {
+    expect(stepDurationLabel(step({ startedAt: 4000 }), NOW, false, null)).toBe('6s')
+    expect(stepDurationLabel(step({ startedAt: 0, finishedAt: 90_000 }), NOW, false, null)).toBe(
+      '1m 30s',
+    )
+  })
+})

package/app/composables/useStepTimer.ts

@@ -1,6 +1,63 @@
 import { ref, computed, onMounted, onUnmounted } from 'vue'
 import type { PipelineStep } from '~/types/execution'
 
+/**
+ * Whether a step is actively executing: it has started, hasn't finished, isn't
+ * parked on a human (`pausedAt`), and the run itself hasn't failed. A step in any
+ * of those states is not ticking — no spinner, no counting-up clock.
+ */
+export function stepIsRunning(step: PipelineStep | null, runFailed: boolean): boolean {
+  return !!step?.startedAt && !step?.finishedAt && step?.pausedAt == null && !runFailed
+}
+
+/**
+ * Elapsed/total execution time in ms for a step at wall-clock `nowMs`, or null until
+ * the step has started. The clock freezes once the step stops working: at its finish,
+ * else at the run's failure time once the run has failed, else at the moment it parked
+ * on a human (`pausedAt`). Otherwise it is live, counting up to `nowMs`.
+ */
+export function stepDurationMs(
+  step: PipelineStep | null,
+  nowMs: number,
+  runFailed: boolean,
+  failureAt: number | null | undefined,
+): number | null {
+  if (step?.startedAt == null) return null
+  const end =
+    step.finishedAt ?? (runFailed ? (failureAt ?? step.startedAt) : (step.pausedAt ?? nowMs))
+  return Math.max(0, end - step.startedAt)
+}
+
+/** Human-friendly elapsed label for a step at `nowMs`, or null until it has started. */
+export function stepDurationLabel(
+  step: PipelineStep | null,
+  nowMs: number,
+  runFailed: boolean,
+  failureAt: number | null | undefined,
+): string | null {
+  const ms = stepDurationMs(step, nowMs, runFailed, failureAt)
+  return ms == null ? null : formatDuration(ms)
+}
+
+/**
+ * A shared 1s wall-clock tick for surfaces that render many steps' live durations
+ * at once (the pipeline timeline, the inspector run list). One interval drives every
+ * step's elapsed label instead of a per-step timer. Stays `0` until mounted so the
+ * first paint never reads a stale time.
+ */
+export function useNowTick(intervalMs = 1000) {
+  const now = ref(0)
+  let timer: ReturnType<typeof setInterval> | undefined
+  onMounted(() => {
+    now.value = Date.now()
+    timer = setInterval(() => (now.value = Date.now()), intervalMs)
+  })
+  onUnmounted(() => {
+    if (timer) clearInterval(timer)
+  })
+  return now
+}
+
 /**
  * Live elapsed-time clock for a single pipeline step. A 1s tick drives the
  * counting-up duration while the step is actively running; the clock freezes at
@@ -12,37 +69,16 @@ export function useStepTimer(opts: {
   runFailed: () => boolean
   failureAt: () => number | null | undefined
 }) {
-  // A 1s tick so a still-running step's elapsed time counts up live while open.
-  const nowTick = ref(0)
-  let timer: ReturnType<typeof setInterval> | undefined
-  onMounted(() => {
-    nowTick.value = Date.now()
-    timer = setInterval(() => (nowTick.value = Date.now()), 1000)
-  })
-  onUnmounted(() => {
-    if (timer) clearInterval(timer)
-  })
+  const nowTick = useNowTick()
 
   // A step that is finished, failed, or parked on a human is not actively
-  // executing — no ticking clock or spinner. `pausedAt` is the "waiting on input"
-  // freeze.
-  const isRunning = computed(() => {
-    const s = opts.step()
-    return !!s?.startedAt && !s?.finishedAt && s?.pausedAt == null && !opts.runFailed()
-  })
+  // executing — no ticking clock or spinner. `pausedAt` is the "waiting on input" freeze.
+  const isRunning = computed(() => stepIsRunning(opts.step(), opts.runFailed()))
 
   /** Elapsed/total execution time in ms — null until the step has started. */
-  const durationMs = computed(() => {
-    const s = opts.step()
-    if (s?.startedAt == null) return null
-    // Freeze the clock once the step stops working: at its finish, else at the
-    // failure time once the run has failed, else at the moment it parked on a
-    // human (`pausedAt`). Otherwise it is live, so count up to the current tick.
-    const end =
-      s.finishedAt ??
-      (opts.runFailed() ? (opts.failureAt() ?? s.startedAt) : (s.pausedAt ?? nowTick.value))
-    return Math.max(0, end - s.startedAt)
-  })
+  const durationMs = computed(() =>
+    stepDurationMs(opts.step(), nowTick.value, opts.runFailed(), opts.failureAt()),
+  )
 
   const durationLabel = computed(() =>
     durationMs.value == null ? null : formatDuration(durationMs.value),
@@ -51,7 +87,7 @@ export function useStepTimer(opts: {
   return { isRunning, durationMs, durationLabel }
 }
 
-function formatDuration(ms: number): string {
+export function formatDuration(ms: number): string {
   const totalSec = Math.round(ms / 1000)
   if (totalSec < 60) return `${totalSec}s`
   const m = Math.floor(totalSec / 60)

package/app/stores/consensus.spec.ts

@@ -0,0 +1,76 @@
+import { describe, it, expect, beforeEach, vi } from 'vitest'
+import { useConsensusStore } from '~/stores/consensus'
+import { useWorkspaceStore } from '~/stores/workspace'
+import type { ConsensusSession } from '~/types/consensus'
+
+/** Minimal session factory — only the fields the store reconciles/reads. */
+function session(over: Partial<ConsensusSession> = {}): ConsensusSession {
+  return {
+    id: 's1',
+    blockId: 'blk1',
+    executionId: null,
+    stepIndex: 0,
+    agentKind: 'architect',
+    strategy: 'panel',
+    status: 'complete',
+    participants: [],
+    rounds: [],
+    synthesis: null,
+    createdAt: 1,
+    updatedAt: 1,
+    ...over,
+  } as ConsensusSession
+}
+
+describe('consensus store — load vs live-push reconcile', () => {
+  beforeEach(() => {
+    useWorkspaceStore().workspaceId = 'ws1'
+  })
+
+  it('load stores the fetched session', async () => {
+    vi.stubGlobal('useApi', () => ({
+      getConsensusSession: () => Promise.resolve({ session: session() }),
+    }))
+    const store = useConsensusStore()
+    await store.load('blk1')
+    expect(store.sessionFor('blk1')?.id).toBe('s1')
+  })
+
+  it('a stale load never regresses a fresher live-pushed session', async () => {
+    // A live `consensus` push delivers the newest transcript; a `load` that started earlier
+    // resolves later with a staler snapshot. It must NOT overwrite the fresher one.
+    let resolveFetch!: (r: { session: ConsensusSession | null }) => void
+    const pending = new Promise<{ session: ConsensusSession | null }>((res) => {
+      resolveFetch = res
+    })
+    vi.stubGlobal('useApi', () => ({ getConsensusSession: () => pending }))
+    const store = useConsensusStore()
+
+    const load = store.load('blk1')
+    store.upsert(session({ updatedAt: 10, synthesis: 'fresh' }))
+    resolveFetch({ session: session({ updatedAt: 2, synthesis: 'stale' }) })
+    await load
+
+    expect(store.sessionFor('blk1')?.synthesis).toBe('fresh')
+  })
+
+  it('a load returning "none" never clobbers an existing live session', async () => {
+    vi.stubGlobal('useApi', () => ({
+      getConsensusSession: () => Promise.resolve({ session: null }),
+    }))
+    const store = useConsensusStore()
+    store.upsert(session({ synthesis: 'live' }))
+    await store.load('blk1')
+    expect(store.sessionFor('blk1')?.synthesis).toBe('live')
+  })
+
+  it('a load returning "none" records the fetched-empty state when nothing is cached', async () => {
+    vi.stubGlobal('useApi', () => ({
+      getConsensusSession: () => Promise.resolve({ session: null }),
+    }))
+    const store = useConsensusStore()
+    await store.load('blk1')
+    expect('blk1' in store.sessions).toBe(true)
+    expect(store.sessionFor('blk1')).toBeNull()
+  })
+})

package/app/stores/consensus.ts

@@ -46,7 +46,17 @@ export const useConsensusStore = defineStore('consensus', () => {
     loading.value = new Set(loading.value).add(blockId)
     try {
       const { session } = await api.getConsensusSession(wsId, blockId)
-      sessions.value = { ...sessions.value, [blockId]: session }
+      // Reconcile rather than blind-replace: a `load` resolving AFTER a fresher live
+      // `consensus` push (or after a newer concurrent load) must not regress the transcript —
+      // the out-of-order-overwrite hazard the CLAUDE.md live-push rules warn about. Keep
+      // whichever session is newer by `updatedAt` (any id), and never overwrite an existing
+      // (possibly live-pushed) session with a raced "none".
+      const existing = sessions.value[blockId]
+      if (session) {
+        if (!existing || session.updatedAt >= existing.updatedAt) store(session)
+      } else if (existing === undefined) {
+        sessions.value = { ...sessions.value, [blockId]: null }
+      }
     } catch {
       // Consensus off / no session — leave the cache as-is; the window shows its empty state.
     } finally {

package/app/stores/docInterview.spec.ts

@@ -0,0 +1,64 @@
+import { describe, it, expect, beforeEach, vi } from 'vitest'
+import { useDocInterviewStore } from '~/stores/docInterview'
+import { useWorkspaceStore } from '~/stores/workspace'
+import type { DocInterviewSession } from '~/types/domain'
+
+/** Minimal session factory — only the fields the store reconciles/reads. */
+function session(over: Partial<DocInterviewSession> = {}): DocInterviewSession {
+  return {
+    id: 'd1',
+    blockId: 'blk1',
+    status: 'awaiting_answers',
+    round: 1,
+    maxRounds: 3,
+    qa: [],
+    brief: null,
+    model: null,
+    createdAt: 1,
+    updatedAt: 1,
+    ...over,
+  } as DocInterviewSession
+}
+
+// docInterview already routes its `load` through `upsert`'s newest-wins (`updatedAt`) guard —
+// these specs pin that so a future refactor can't reintroduce a blind-replace clobber.
+describe('docInterview store — load vs live-push reconcile', () => {
+  beforeEach(() => {
+    useWorkspaceStore().workspaceId = 'ws1'
+  })
+
+  it('load stores the fetched session', async () => {
+    vi.stubGlobal('useApi', () => ({
+      getDocInterview: () => Promise.resolve(session()),
+    }))
+    const store = useDocInterviewStore()
+    await store.load('blk1')
+    expect(store.forBlock('blk1')?.id).toBe('d1')
+  })
+
+  it('a stale load never regresses a fresher live-pushed session', async () => {
+    let resolveFetch!: (r: DocInterviewSession | null) => void
+    const pending = new Promise<DocInterviewSession | null>((res) => {
+      resolveFetch = res
+    })
+    vi.stubGlobal('useApi', () => ({ getDocInterview: () => pending }))
+    const store = useDocInterviewStore()
+
+    const load = store.load('blk1')
+    store.upsert(session({ updatedAt: 10, round: 2 }))
+    resolveFetch(session({ updatedAt: 2, round: 1 }))
+    await load
+
+    expect(store.forBlock('blk1')?.round).toBe(2)
+  })
+
+  it('a load returning "none" leaves the cache untouched', async () => {
+    vi.stubGlobal('useApi', () => ({
+      getDocInterview: () => Promise.resolve(null),
+    }))
+    const store = useDocInterviewStore()
+    store.upsert(session({ round: 2 }))
+    await store.load('blk1')
+    expect(store.forBlock('blk1')?.round).toBe(2)
+  })
+})