@cat-factory/app 0.232.2 → 0.234.0

package/app/stores/taskTypes.ts

@@ -28,6 +28,11 @@ export const useTaskTypesStore = defineStore('taskTypes', () => {
   // The active per-workspace capability manifest (shared with the agents store), or null before
   // the first hydrate. This store reads only its own `taskTypes` slot off it.
   const capabilitiesManifest = ref<RemoteModuleManifest<AppSlots> | null>(null)
+  // The BACKEND-registered ids this board HIDES (`snapshot.suppressedTaskTypes`). Not part of the
+  // catalog above by construction (a suppressed type must not be creatable), but the board did
+  // decide about it, and that decision is the difference between a deployment with no operations
+  // and one whose operations are all hidden. See {@link hasRegisteredOperations}.
+  const suppressedTaskTypes = ref<string[]>([])
 
   /**
    * The merged CUSTOM task types (consumer-slot → backend-manifest), de-duplicated and never
@@ -47,6 +52,23 @@ export const useTaskTypesStore = defineStore('taskTypes', () => {
     return out
   })
 
+  /**
+   * Whether this deployment registers any REUSABLE OPERATION on the backend, hidden or not: what
+   * decides whether the workspace-settings Operations tab exists.
+   *
+   * Deliberately NOT `customTaskTypes.length`. That list is what the board OFFERS, so hiding the
+   * last operation empties it and the tab that un-hides one would disappear with it, leaving no
+   * way back short of an API call. The suppressed ids are the other half of the same catalog.
+   *
+   * Consumer CODE-shipped types are excluded on purpose: they have no backend row to suppress, so
+   * a deployment that ships only those has nothing for that screen to manage.
+   */
+  const hasRegisteredOperations = computed<boolean>(
+    () =>
+      (capabilitiesManifest.value?.slots?.taskTypes ?? []).length > 0 ||
+      suppressedTaskTypes.value.length > 0,
+  )
+
   /** The custom types indexed by id, for a per-type lookup (e.g. the create-form field descriptors). */
   const byTaskType = computed<Record<string, CustomTaskType>>(() =>
     Object.fromEntries(customTaskTypes.value.map((t) => [t.taskType, t])),
@@ -84,5 +106,22 @@ export const useTaskTypesStore = defineStore('taskTypes', () => {
     capabilitiesManifest.value = manifest
   }
 
-  return { customTaskTypes, get, registerConsumerTaskTypes, hydrateCapabilities }
+  /**
+   * The suppressed-id half of the same snapshot read. Assigned unconditionally (an absent field is
+   * an empty list): this is per-WORKSPACE state, so carrying the previous board's answer forward
+   * would leave the Operations tab standing on a board that hid nothing.
+   */
+  function hydrateSuppressed(ids: readonly string[]) {
+    suppressedTaskTypes.value = [...ids]
+  }
+
+  return {
+    customTaskTypes,
+    suppressedTaskTypes,
+    hasRegisteredOperations,
+    get,
+    registerConsumerTaskTypes,
+    hydrateCapabilities,
+    hydrateSuppressed,
+  }
 })

package/app/stores/workspace/hydrate.ts

@@ -71,6 +71,7 @@ export function applySnapshotToStores(snapshot: WorkspaceSnapshot, boardSince?:
     snapshot.pipelines,
     snapshot.pipelineCatalogVersions,
     snapshot.retiredPipelines,
+    snapshot.pipelineCatalogNames,
   )
   useExecutionStore().hydrate(snapshot.executions, snapshot.workspace.id)
   useAgentRunsStore().hydrate(snapshot.bootstrapJobs ?? [], snapshot.workspace.id)
@@ -114,6 +115,10 @@ export function applySnapshotToStores(snapshot: WorkspaceSnapshot, boardSince?:
     snapshot.binaryGeneratorsUnavailable === true,
   )
   useTaskTypesStore().hydrateCapabilities(capabilities)
+  // The complement of the offered catalog above: the registered operations this board HIDES. Both
+  // halves come from the one snapshot, so the settings screen can exist for a board that hid
+  // every one of them (the state whose only way back is that screen).
+  useTaskTypesStore().hydrateSuppressed(snapshot.suppressedTaskTypes ?? [])
   // The per-step parameters each registered gate declares, so a gated step's config form in the
   // builder comes from the gate's own registration rather than a form hard-coded per gate.
   usePipelinesStore().hydrateGateConfigForms(snapshot.gateConfigForms ?? [])

package/app/types/domain.ts

@@ -67,6 +67,9 @@ export type {
   TaskTypePresentation,
   TaskTypeFieldDescriptor,
   TaskTypeFieldOption,
+  // One row of the workspace's operation-suppression screen: a registered custom task type plus
+  // whether THIS board hides it (`backend/docs/reusable-operations.md`).
+  TaskTypeSuppression,
   // The shared descriptor-driven form vocabulary (`contracts/src/form-fields.ts`): one field
   // shape and one filled-value bag behind both the initiative-preset form and a custom task
   // type's per-case form, so `DescriptorFields.vue` renders either.

package/app/types/execution.ts

@@ -24,6 +24,7 @@ export type {
   StepPhaseMetrics,
   LlmCallMetric,
   LlmCallActivity,
+  LlmCallOutcome,
   LlmExportInsight,
   LlmMetricsExport,
   PlatformObservability,
@@ -47,6 +48,11 @@ export type {
   ReportTotals,
   ReportsView,
   AgentSearchQuery,
+  AgentToolCall,
+  RunToolCallFailures,
+  RunToolCallTrajectory,
+  ToolCallBodiesState,
+  ToolCallOutcome,
   WebSearchAvailability,
   WebSearchProvider,
   PipelineStep,

package/app/utils/descriptorFields.ts

@@ -1,40 +1,26 @@
+import { descriptorFieldDefaults } from '@cat-factory/contracts'
 import type { DescriptorField, DescriptorFieldValue, DescriptorFieldValues } from '~/types/domain'
 
 // Form-side helpers over the shared descriptor-field vocabulary (`contracts/src/form-fields.ts`),
 // used by every surface that renders one through `DescriptorFields.vue`: an initiative preset's
 // create form and a reusable operation's per-case form on a custom task type.
 //
-// The RULES (visibility, validation, sanitization, prose rendering) live in contracts, because the
-// server has to agree about them. What lives here is what only a FORM decides: which values to
-// start it with, and how one edit changes the bag. Both are pure functions over the value bag
-// rather than methods inside the SFC, so the mutation rules a wrong answer would freeze on an
-// entity are unit-testable without mounting a component.
+// The RULES (visibility, validation, sanitization, prose rendering, and now default seeding) live
+// in contracts, because the server has to agree about them. What lives here is what only a FORM
+// decides: how one edit changes the bag. Pure functions over the value bag rather than methods
+// inside the SFC, so the mutation rules a wrong answer would freeze on an entity are unit-testable
+// without mounting a component.
 
 /**
- * The initial, typed values a field list implies: its declared DEFAULTS folded into the
- * `DescriptorFieldValues` shape the renderer and the wire contract expect (`checkbox-group` to
- * `string[]`, `checkbox` to a boolean, `number` to a number, everything else a string). Only fields
- * with a meaningful default are seeded, so an unfilled optional field stays absent (which is what
- * validation reads as unset) and never freezes an empty value. A repo-detection probe's prefill and
- * the user's own edits layer on top.
+ * The initial values a field list implies, for seeding a freshly opened form. A repo-detection
+ * probe's prefill and the user's own edits layer on top.
+ *
+ * The SHARED helper, not a form-side copy: the server folds the same defaults in at the creation
+ * door (`withDescriptorFieldDefaults`), so a duplicate here would be the drift that made a headless
+ * caller and this form disagree about what a descriptor's default means.
  */
 export function defaultDescriptorValues(fields: readonly DescriptorField[]): DescriptorFieldValues {
-  const values: DescriptorFieldValues = {}
-  for (const field of fields) {
-    if (field.type === 'checkbox-group') {
-      if (field.defaultValues?.length) values[field.key] = [...field.defaultValues]
-    } else if (field.type === 'checkbox') {
-      if (field.default === 'true') values[field.key] = true
-    } else if (field.type === 'number') {
-      const parsed = Number(field.default)
-      if (field.default !== undefined && field.default !== '' && Number.isFinite(parsed)) {
-        values[field.key] = parsed
-      }
-    } else if (field.default) {
-      values[field.key] = field.default
-    }
-  }
-  return values
+  return descriptorFieldDefaults(fields)
 }
 
 /**

package/app/utils/observability.spec.ts

@@ -1,6 +1,26 @@
 import { describe, it, expect } from 'vitest'
-import type { PipelineStep, StepPhaseMetrics } from '~/types/execution'
-import { foldRunPhaseMetrics, formatCost, sumCosts, totalInputTokens } from './observability'
+import type {
+  AgentFailure,
+  AgentToolCall,
+  LlmCallMetric,
+  PipelineStep,
+  RunToolCallFailures,
+  StepPhaseMetrics,
+} from '~/types/execution'
+import type { SinkAnswer } from './observability'
+import {
+  countCallOutcomes,
+  deriveRunFailureEvidence,
+  filterCallsByOutcome,
+  filterToolCallsByOutcome,
+  foldRunPhaseMetrics,
+  formatCost,
+  hasFailureEvidence,
+  noFailingCallReason,
+  sinkAnswer,
+  sumCosts,
+  totalInputTokens,
+} from './observability'
 
 describe('totalInputTokens', () => {
   it('sums all three input classes, so the headline matches Claude Code’s context gauge', () => {
@@ -128,3 +148,294 @@ describe('sumCosts', () => {
     expect(sumCosts([undefined])).toBeNull()
   })
 })
+
+describe('failing-call-first triage', () => {
+  const call = (over: Partial<LlmCallMetric> & Pick<LlmCallMetric, 'id'>): LlmCallMetric =>
+    ({
+      workspaceId: 'ws',
+      executionId: 'run',
+      agentKind: 'coder',
+      provider: 'anthropic',
+      model: 'm',
+      createdAt: 1,
+      streaming: false,
+      phase: 'agent',
+      turnIndex: null,
+      messageCount: 1,
+      toolCount: 0,
+      requestMaxTokens: null,
+      promptTokens: 0,
+      cacheReadTokens: 0,
+      cacheWriteTokens: 0,
+      completionTokens: 0,
+      totalTokens: 0,
+      finishReason: 'stop',
+      upstreamMs: 1,
+      overheadMs: 1,
+      totalMs: 2,
+      ok: true,
+      httpStatus: 200,
+      errorMessage: null,
+      promptText: '',
+      promptPrefixCount: 0,
+      promptHash: '',
+      responseText: '',
+      reasoningText: '',
+      ...over,
+    }) as LlmCallMetric
+
+  const tool = (over: Partial<AgentToolCall> & Pick<AgentToolCall, 'id'>): AgentToolCall => ({
+    workspaceId: 'ws',
+    executionId: 'run',
+    agentKind: 'coder',
+    jobId: 'job',
+    seq: 0,
+    tool: 'bash',
+    startedAt: 1,
+    endedAt: 2,
+    ok: true,
+    bodies: 'stored',
+    args: '',
+    result: '',
+    argsDropped: 0,
+    resultDropped: 0,
+    createdAt: 1,
+    ...over,
+  })
+
+  /** An untruncated failure read holding exactly these rows: the ordinary case. */
+  const toolFailures = (
+    failures: AgentToolCall[],
+    total = failures.length,
+  ): RunToolCallFailures => ({
+    total,
+    failed: failures.length,
+    failures,
+    failuresTruncated: false,
+  })
+
+  const failure = (): AgentFailure => ({
+    kind: 'agent',
+    message: 'the coder step failed',
+    detail: null,
+    hint: null,
+    occurredAt: 5,
+    lastSubtasks: null,
+  })
+
+  describe('countCallOutcomes', () => {
+    it('keeps a failed call and a TRUNCATED one in different buckets', () => {
+      // They need different fixes (transport/proxy/spend versus an output limit), so a filter
+      // that lumped them together would send an operator to the wrong conversation.
+      const counts = countCallOutcomes([
+        call({ id: 'a' }),
+        call({ id: 'b', ok: false, finishReason: null }),
+        call({ id: 'c', finishReason: 'length' }),
+        call({ id: 'd', finishReason: 'content_filter' }),
+      ])
+      expect(counts).toEqual({ all: 4, ok: 1, warning: 2, error: 1 })
+    })
+
+    it('counts a failed call as an error even when its finish reason looks like a warning', () => {
+      // `ok: false` wins: a call that failed AND reported `length` is a failure, not a
+      // truncation, and counting it in both buckets would make the chips sum past the total.
+      const counts = countCallOutcomes([call({ id: 'a', ok: false, finishReason: 'length' })])
+      expect(counts).toEqual({ all: 1, ok: 0, warning: 0, error: 1 })
+    })
+  })
+
+  describe('filterCallsByOutcome', () => {
+    const calls = [
+      call({ id: 'ok' }),
+      call({ id: 'warn', finishReason: 'length' }),
+      call({ id: 'err', ok: false }),
+    ]
+
+    it('narrows to one class and passes everything through on `all`', () => {
+      expect(filterCallsByOutcome(calls, 'error').map((c) => c.id)).toEqual(['err'])
+      expect(filterCallsByOutcome(calls, 'warning').map((c) => c.id)).toEqual(['warn'])
+      expect(filterCallsByOutcome(calls, 'all').map((c) => c.id)).toEqual(['ok', 'warn', 'err'])
+    })
+
+    it('returns a fresh array, never the caller’s own list', () => {
+      // The panel holds the store's array; a filter that aliased it on `all` would let a sort in
+      // the component reorder the store.
+      expect(filterCallsByOutcome(calls, 'all')).not.toBe(calls)
+    })
+  })
+
+  describe('filterToolCallsByOutcome', () => {
+    it('narrows a trajectory to the failing calls, keeping their order', () => {
+      const trajectory = [
+        tool({ id: '1' }),
+        tool({ id: '2', ok: false }),
+        tool({ id: '3' }),
+        tool({ id: '4', ok: false }),
+      ]
+      expect(filterToolCallsByOutcome(trajectory, 'error').map((c) => c.id)).toEqual(['2', '4'])
+      expect(filterToolCallsByOutcome(trajectory, 'ok').map((c) => c.id)).toEqual(['1', '3'])
+      expect(filterToolCallsByOutcome(trajectory, 'all')).toHaveLength(4)
+    })
+  })
+
+  describe('deriveRunFailureEvidence', () => {
+    /** Both sinks answered with the given rows. */
+    const answered = (rows: number): SinkAnswer => ({ status: 'answered', rows })
+    const evidenceFor = (input: {
+      failure?: AgentFailure | null
+      calls?: LlmCallMetric[]
+      toolFailures?: RunToolCallFailures | null
+    }) => {
+      const calls = input.calls ?? []
+      const toolFailures = input.toolFailures ?? null
+      return deriveRunFailureEvidence({
+        failure: input.failure ?? null,
+        calls,
+        callsAnswer: answered(calls.length),
+        toolFailures,
+        toolsAnswer: toolFailures ? answered(toolFailures.total) : { status: 'pending' },
+      })
+    }
+
+    it('picks the LAST failing row from each sink, respecting their opposite orders', () => {
+      // Calls arrive newest-first; the failing tool calls arrive oldest-first (trajectory order).
+      // Reading either the wrong way round still yields a failing call, just not the one nearest
+      // the failure, which is the only reason to pin one.
+      const evidence = evidenceFor({
+        failure: failure(),
+        calls: [
+          call({ id: 'newest-error', ok: false, createdAt: 30 }),
+          call({ id: 'older-error', ok: false, createdAt: 10 }),
+        ],
+        toolFailures: toolFailures([
+          tool({ id: 'oldest-fail', ok: false, startedAt: 10 }),
+          tool({ id: 'latest-fail', ok: false, startedAt: 30 }),
+        ]),
+      })
+      expect(evidence.lastErroredCall?.id).toBe('newest-error')
+      expect(evidence.lastFailedToolCall?.id).toBe('latest-fail')
+      expect(evidence.erroredCallCount).toBe(2)
+      expect(evidence.failedToolCallCount).toBe(2)
+    })
+
+    it('counts failing tool calls off the run AGGREGATE, never off the rows it holds', () => {
+      // The failure this split exists to prevent. The backend narrows and counts over the whole
+      // run; the rows come back bounded. A count taken from the list would under-report exactly
+      // the long runs worth opening the panel for, and would disagree with the debug overview's
+      // `toolCalls.totals.failures` on the same run.
+      const evidence = evidenceFor({
+        failure: failure(),
+        toolFailures: {
+          total: 5_000,
+          failed: 240,
+          failures: [tool({ id: 'held', ok: false })],
+          failuresTruncated: true,
+        },
+      })
+      expect(evidence.failedToolCallCount).toBe(240)
+      expect(evidence.failedToolCallsTruncated).toBe(true)
+      expect(evidence.lastFailedToolCall?.id).toBe('held')
+    })
+
+    it('reports a run whose model calls are all healthy but whose tools are not', () => {
+      // The whole failure class this surface exists for: the model call that requested the tool
+      // still reports `ok`, so every LLM rollup reads clean.
+      const evidence = evidenceFor({
+        failure: failure(),
+        calls: [call({ id: 'fine' })],
+        toolFailures: toolFailures([tool({ id: 'broke', ok: false })]),
+      })
+      expect(evidence.lastErroredCall).toBeNull()
+      expect(evidence.lastFailedToolCall?.id).toBe('broke')
+      expect(hasFailureEvidence(evidence)).toBe(true)
+    })
+
+    it('has nothing to pin for a run that neither failed nor recorded a failing call', () => {
+      expect(hasFailureEvidence(evidenceFor({ calls: [call({ id: 'a' })] }))).toBe(false)
+    })
+
+    it('pins the section for an UNREACHABLE sink even with no failure and no failing call', () => {
+      // "One of these reads did not come back" has to reach the operator before they read the
+      // rest of the page as whole. Staying silent is how the other numbers get believed.
+      const evidence = deriveRunFailureEvidence({
+        failure: null,
+        calls: [],
+        callsAnswer: { status: 'answered', rows: 0 },
+        toolFailures: null,
+        toolsAnswer: { status: 'unreachable' },
+      })
+      expect(hasFailureEvidence(evidence)).toBe(true)
+    })
+  })
+
+  describe('sinkAnswer', () => {
+    it('reports an in-flight read as pending whatever it is still holding', () => {
+      // A refresh over a previous answer (or a previous error) is not that answer: what the panel
+      // says next depends on what is coming back.
+      expect(sinkAnswer({ loading: true, error: 'boom', loaded: true, rows: 3 })).toEqual({
+        status: 'pending',
+      })
+    })
+
+    it('separates a failed read from an answer of zero rows', () => {
+      expect(sinkAnswer({ loading: false, error: 'boom', loaded: false, rows: 0 })).toEqual({
+        status: 'unreachable',
+      })
+      expect(sinkAnswer({ loading: false, error: null, loaded: true, rows: 0 })).toEqual({
+        status: 'answered',
+        rows: 0,
+      })
+    })
+
+    it('treats never-requested as pending, not as an answer', () => {
+      expect(sinkAnswer({ loading: false, error: null, loaded: false, rows: 0 })).toEqual({
+        status: 'pending',
+      })
+    })
+  })
+
+  describe('noFailingCallReason', () => {
+    const reasonFor = (calls: SinkAnswer, tools: SinkAnswer, failed = 0) =>
+      noFailingCallReason(
+        deriveRunFailureEvidence({
+          failure: failure(),
+          calls: [],
+          callsAnswer: calls,
+          toolFailures: { total: 0, failed, failures: [], failuresTruncated: false },
+          toolsAnswer: tools,
+        }),
+      )
+    const answered = (rows: number): SinkAnswer => ({ status: 'answered', rows })
+
+    it('says nothing when a failing call WAS found', () => {
+      expect(reasonFor(answered(1), answered(1), 1)).toBeNull()
+    })
+
+    it('distinguishes "both sinks answered and nothing failed" from "nothing was recorded"', () => {
+      // The distinction the whole helper exists for: an unwired sink, a capture opt-out and a
+      // container that died before reporting all produce zero failing rows, exactly like a run
+      // whose every call succeeded, and only one of those is a clean bill of health.
+      expect(reasonFor(answered(1), answered(1))).toBe('recorded-clean')
+      expect(reasonFor(answered(0), answered(0))).toBe('no-telemetry')
+    })
+
+    it('names WHICH sink is empty when only one holds rows', () => {
+      expect(reasonFor(answered(1), answered(0))).toBe('partial-calls-only')
+      expect(reasonFor(answered(0), answered(1))).toBe('partial-tools-only')
+    })
+
+    it('withholds every verdict while a sink has not answered yet', () => {
+      // A read still in flight is not a read that came back clean, and rendering it as one is a
+      // clean bill of health written before the evidence arrived.
+      expect(reasonFor({ status: 'pending' }, answered(1))).toBeNull()
+      expect(reasonFor(answered(1), { status: 'pending' })).toBeNull()
+    })
+
+    it('lets an UNREACHABLE sink outrank every statement about the run', () => {
+      // Each other reason is a claim about the run. This is the one case where the panel has no
+      // standing to make one, so it must win even against a sink that answered richly.
+      expect(reasonFor({ status: 'unreachable' }, answered(9))).toBe('sink-unreachable')
+      expect(reasonFor(answered(9), { status: 'unreachable' })).toBe('sink-unreachable')
+    })
+  })
+})