@cat-factory/app 0.242.2 → 0.244.0

package/app/components/board/RecurringPipelineModal.vue

@@ -175,8 +175,11 @@ const intakeDispatch = computed<'queue' | 'per-ticket'>(() =>
   isBugIntake.value ? 'queue' : 'per-ticket',
 )
 
-// Sources that can back intake right now (connected / App-installed AND enabled).
-const intakeSources = computed(() => tasks.offeredSources)
+// Sources that can back intake right now: connected / App-installed AND enabled, AND able to run
+// the predicate search intake fires. The last is not a refinement of the first two — a source
+// without it saves a schedule that can never produce a ticket — so it is asked of the server
+// (`supportsIntake`, derived from the registered provider) rather than inferred from the id here.
+const intakeSources = computed(() => tasks.offeredSources.filter((s) => s.supportsIntake))
 
 watch(open, (isOpen) => {
   if (!isOpen) return
@@ -490,8 +493,14 @@ async function add() {
           <p class="text-[11px] text-slate-500">
             {{ t('board.recurring.intakeHint') }}
           </p>
+          <!-- Two different remedies: connect something, versus connect something ELSE. A source
+               that is connected but cannot run a scheduled search is not an absent connection. -->
           <p v-if="intakeSources.length === 0" class="text-[11px] text-amber-500">
-            {{ t('board.recurring.intakeNoSources') }}
+            {{
+              tasks.anyOffered
+                ? t('board.recurring.intakeNoIntakeSources')
+                : t('board.recurring.intakeNoSources')
+            }}
           </p>
           <div v-else class="flex flex-wrap gap-1">
             <UButton

package/app/components/panels/StepToolServers.logic.spec.ts

@@ -1,12 +1,18 @@
 import { describe, it, expect } from 'vitest'
 import {
+  KNOWN_OBSERVED_STATUSES,
   KNOWN_REASONS,
+  OBSERVED_STATUS_KEY,
   REASON_KEY,
   REMEDY_KEY,
+  observationFor,
+  observationIsFault,
+  observationText,
   reasonText,
   remedyText,
+  unattributedObservations,
 } from './StepToolServers.logic'
-import type { ToolServerUnavailableReason } from '~/types/toolServers'
+import type { ObservedToolServer, ToolServerUnavailableReason } from '~/types/toolServers'
 
 /**
  * A dropped tool server is the whole point of this surface: until it existed, a run that quietly
@@ -98,3 +104,104 @@ function render(reason: string): { key: string; params?: Record<string, unknown>
   })
   return seen
 }
+
+/**
+ * The OBSERVED half: what the agent's CLI said about the servers the platform wired. Its whole
+ * value is a set of distinctions, and each one collapses into "looks fine" if it is lost — so
+ * these pin the distinctions rather than the copy.
+ */
+describe('tool-server startup observations', () => {
+  it('gives every observed status but `ready` its own copy', () => {
+    // `ready` is deliberately absent: a started server's line depends on its tool count, which is
+    // three sentences rather than one key. Everything else is exhaustive against the schema, so a
+    // member added on the backend fails here instead of rendering blank.
+    expect([...Object.keys(OBSERVED_STATUS_KEY), 'ready'].sort()).toEqual(
+      [...KNOWN_OBSERVED_STATUSES].sort(),
+    )
+    const keys = Object.values(OBSERVED_STATUS_KEY)
+    expect(new Set(keys).size).toBe(keys.length)
+  })
+
+  it('says NOTHING when no observation was made', () => {
+    // The distinction the whole field rests on. A codex run, an image one version behind and an
+    // unmapped runner pool all report nothing, and any placeholder here would read as a verdict
+    // about a server that was very likely fine.
+    expect(observationFor(undefined, 'slack')).toBeNull()
+    expect(observationText(null, (key) => key)).toBeNull()
+    expect(observationIsFault(null)).toBe(false)
+  })
+
+  it('distinguishes “nobody looked” from “the CLI never loaded it”', () => {
+    // Both render as an absent server on the chip if they are conflated, and only the second is
+    // evidence of anything. The first must never raise a fault.
+    const notLoaded = observationFor([{ id: 'jira', status: 'ready' }], 'slack')
+    expect(notLoaded).toEqual({ kind: 'not_loaded' })
+    expect(observationText(notLoaded, (key) => key)).toBe(
+      'panels.stepDetail.toolServers.observed.notLoaded',
+    )
+    expect(observationIsFault(notLoaded)).toBe(true)
+  })
+
+  it('separates “started with no tools” from “started, tools uncounted”', () => {
+    // A server that connected and exposes nothing reaches the agent exactly like one that was
+    // never wired, and every other signal about it says healthy — so it gets its own sentence
+    // rather than a "0 tools" that reads as a rendering artefact.
+    const none = observationFor([{ id: 'slack', status: 'ready', toolCount: 0 }], 'slack')
+    const uncounted = observationFor([{ id: 'slack', status: 'ready' }], 'slack')
+    const some = observationFor([{ id: 'slack', status: 'ready', toolCount: 3 }], 'slack')
+    expect(observationText(none, (key) => key)).toBe(
+      'panels.stepDetail.toolServers.observed.readyNoTools',
+    )
+    expect(observationText(uncounted, (key) => key)).toBe(
+      'panels.stepDetail.toolServers.observed.ready',
+    )
+    expect(observationText(some, (key) => key)).toBe(
+      'panels.stepDetail.toolServers.observed.readyTools',
+    )
+    // None of the three is a fault: the count is a diagnosis for a person to read, not a verdict
+    // the surface should paint red.
+    for (const observation of [none, uncounted, some]) {
+      expect(observationIsFault(observation)).toBe(false)
+    }
+  })
+
+  it('flags the two states the platform promised a tool it did not get', () => {
+    for (const status of ['failed', 'needs_auth'] as const) {
+      expect(observationIsFault(observationFor([{ id: 'slack', status }], 'slack'))).toBe(true)
+    }
+  })
+
+  it('never flags a state the report did not resolve', () => {
+    // `unknown` is a fact about THIS build (a word it could not map) or about the moment the
+    // report was taken (a server still handshaking), never about the server itself. Painting it
+    // as a fault would send an operator to debug a working integration every time a CLI adds a
+    // status word or starts a server a moment slower than the session announcement.
+    // Cast, because the point is a value the TYPE excludes and the DATA carries: the vocabulary
+    // is persisted on a run, so a status recorded by a newer harness (or retired since) reads back
+    // here as a member this build has no case for.
+    const persisted = observationFor(
+      [{ id: 'slack', status: 'reticulating' } as unknown as ObservedToolServer],
+      'slack',
+    )
+    expect(persisted).toEqual({ kind: 'loaded', status: 'unknown' })
+    expect(observationIsFault(persisted)).toBe(false)
+  })
+
+  it('states a report naming servers the dispatch did not wire', () => {
+    // Empty on every ordinary run (`--strict-mcp-config`). The only way to reach it is a producer
+    // describing some OTHER job, and silently filtering those rows would present that report as
+    // this run's clean bill of health.
+    const record = {
+      agentKind: 'coder',
+      wired: [{ id: 'slack', label: 'Slack', transport: 'http' as const }],
+      unavailable: [],
+      observed: [
+        { id: 'slack', status: 'ready' as const },
+        { id: 'stranger', status: 'ready' as const },
+      ],
+    }
+    expect(unattributedObservations(record).map((s) => s.id)).toEqual(['stranger'])
+    // …and nothing to state when there was no report at all.
+    expect(unattributedObservations({ ...record, observed: undefined })).toEqual([])
+  })
+})

package/app/components/panels/StepToolServers.logic.ts

@@ -1,5 +1,13 @@
-import { toolServerUnavailableReasonSchema } from '@cat-factory/contracts'
-import type { ToolServerUnavailableReason } from '~/types/toolServers'
+import {
+  toolServerObservedStatusSchema,
+  toolServerUnavailableReasonSchema,
+} from '@cat-factory/contracts'
+import type {
+  ObservedToolServer,
+  StepToolServers,
+  ToolServerObservedStatus,
+  ToolServerUnavailableReason,
+} from '~/types/toolServers'
 
 // The step surface's tool-server (MCP) reason mapping. Kept out of the SFC on the same seam as
 // `StepTestReport.logic.ts`, so the vocabulary rule can be asserted without mounting a component.
@@ -102,3 +110,143 @@ export function remedyText(
 ): string | null {
   return isKnownReason(reason) ? t(REMEDY_KEY[reason]) : null
 }
+
+// ---------------------------------------------------------------------------
+// The OBSERVED half: what the agent's CLI reported about the servers it loaded.
+//
+// The mapping above answers "why did the platform withhold this tool". This one answers the
+// question that mapping structurally cannot: a server that passed every check, was promised to the
+// agent in its prompt, and then did not come up. The two are rendered together on one chip because
+// they are two halves of one answer about one server — but they are never merged into one status,
+// because a withheld server and a failed one need different people to fix different things.
+// ---------------------------------------------------------------------------
+
+/**
+ * What this build knows about one WIRED server after joining the CLI's report onto it.
+ *
+ * `null` and `not_loaded` are the pair this whole type exists to keep apart, and conflating them is
+ * the mistake that would make the surface lie. `null` means NO OBSERVATION WAS MADE — the run's
+ * harness publishes no report (codex's CLI does not, nor does any image older than the one that
+ * introduced this, nor an unmapped runner pool) — so nothing at all is known about whether the
+ * server started. `not_loaded` means an observation WAS made and this server was not in it, which
+ * is positive evidence that the CLI never loaded it. Rendering the first as the second would
+ * accuse every wired server on every deployment one image behind.
+ */
+export type ToolServerObservation =
+  | null
+  | { kind: 'loaded'; status: ToolServerObservedStatus; toolCount?: number }
+  | { kind: 'not_loaded' }
+
+/**
+ * Join the CLI's report onto one wired server id.
+ *
+ * Takes the whole `observed` field rather than a prepared map so the absent-vs-empty decision is
+ * made HERE, in the one place that owns the distinction, instead of by each caller building the
+ * map. An absent field yields `null` for every server; a present one yields either the CLI's line
+ * or `not_loaded`.
+ */
+export function observationFor(
+  observed: readonly ObservedToolServer[] | undefined,
+  id: string,
+): ToolServerObservation {
+  if (!observed) return null
+  const found = observed.find((server) => server.id === id)
+  if (!found) return { kind: 'not_loaded' }
+  return {
+    kind: 'loaded',
+    status: isKnownObservedStatus(found.status) ? found.status : 'unknown',
+    // Carried only when the CLI counted, and `0` is carried: a server that connected and exposed
+    // nothing reaches the agent exactly like one that was never wired, so it is the most
+    // diagnostic count on the field and the one a truthiness guard would erase.
+    ...(typeof found.toolCount === 'number' ? { toolCount: found.toolCount } : {}),
+  }
+}
+
+/**
+ * The servers the CLI named that this step's record does not list as wired.
+ *
+ * Empty by construction on every ordinary run: the harness starts the CLI under
+ * `--strict-mcp-config`, so the only servers it can load are the ones this dispatch wrote for it.
+ * Surfaced anyway rather than filtered out, because the one way to reach it is a producer whose
+ * report does not describe this job — a runner-pool manifest pointing `toolServersPath` at the
+ * wrong field, say — and a surface that silently dropped those rows would present a report about
+ * some other job as a clean bill of health for this one.
+ */
+export function unattributedObservations(record: StepToolServers): ObservedToolServer[] {
+  if (!record.observed) return []
+  const wired = new Set(record.wired.map((server) => server.id))
+  return record.observed.filter((server) => !wired.has(server.id))
+}
+
+/**
+ * The i18n key per observed status, for a server the CLI DID name. An exhaustive `Record` for the
+ * same reason {@link REASON_KEY} is one: a member added to the wire vocabulary must fail to
+ * compile here rather than render as a blank line.
+ *
+ * `ready` is deliberately absent — a started server's line depends on its tool COUNT, which is
+ * three separate sentences (counted some, counted none, did not count), so it is resolved by
+ * {@link observationText} rather than by a single key.
+ */
+export const OBSERVED_STATUS_KEY: Record<Exclude<ToolServerObservedStatus, 'ready'>, string> = {
+  failed: 'panels.stepDetail.toolServers.observed.failed',
+  needs_auth: 'panels.stepDetail.toolServers.observed.needsAuth',
+  unknown: 'panels.stepDetail.toolServers.observed.unknown',
+}
+
+/** The observed-status vocabulary as the SCHEMA states it: what a parity assertion grades against. */
+export const KNOWN_OBSERVED_STATUSES = toolServerObservedStatusSchema.options
+
+/**
+ * Whether a persisted status is a member THIS build knows, derived from the picklist's own options.
+ * A predicate rather than a truthiness check on the lookup, for the reason {@link isKnownReason}
+ * gives: an `Object.prototype` member name reads back as a truthy non-key.
+ */
+export function isKnownObservedStatus(status: string): status is ToolServerObservedStatus {
+  return (KNOWN_OBSERVED_STATUSES as readonly string[]).includes(status)
+}
+
+/**
+ * Render one observation, or `null` when there is nothing to say.
+ *
+ * `null` is returned for `null` — no observation was made — and it is the whole reason this
+ * function exists rather than a template expression: the surface must be BYTE-FOR-BYTE what it was
+ * before this field existed on every run that carries no report, which is every codex run, every
+ * run on an image one version behind, and every run on an unmapped runner pool. Silence is the
+ * only honest rendering of "nobody looked".
+ */
+export function observationText(
+  observation: ToolServerObservation,
+  t: (key: string, params?: Record<string, unknown>) => string,
+): string | null {
+  if (observation === null) return null
+  if (observation.kind === 'not_loaded') {
+    return t('panels.stepDetail.toolServers.observed.notLoaded')
+  }
+  if (observation.status !== 'ready') return t(OBSERVED_STATUS_KEY[observation.status])
+  if (observation.toolCount === undefined) {
+    return t('panels.stepDetail.toolServers.observed.ready')
+  }
+  // Zero gets its own sentence rather than "0 tools": a server that started and offers nothing is
+  // a distinct fault (a narrowed `allowedTools` matching nothing, a vendor that authenticated and
+  // served an empty catalog), and it is the one an operator would otherwise never suspect,
+  // because every other signal about it says healthy.
+  return observation.toolCount === 0
+    ? t('panels.stepDetail.toolServers.observed.readyNoTools')
+    : t('panels.stepDetail.toolServers.observed.readyTools', { count: observation.toolCount })
+}
+
+/**
+ * Whether an observation should DRAW ATTENTION on the chip: the server was promised to the agent
+ * and the CLI could not deliver it.
+ *
+ * `unknown` is deliberately NOT alarming. It covers a word this build could not map (a fact about
+ * this build rather than about the server) and a server the CLI reported as still handshaking when
+ * it announced the session (a fact about the moment the report was taken). Neither says anything
+ * happened to the server, and painting either as a fault would send an operator to debug a working
+ * integration every time a CLI adds a status or starts a server a moment slower.
+ */
+export function observationIsFault(observation: ToolServerObservation): boolean {
+  if (observation === null) return false
+  if (observation.kind === 'not_loaded') return true
+  return observation.status === 'failed' || observation.status === 'needs_auth'
+}

package/app/components/panels/StepToolServers.vue

@@ -8,6 +8,13 @@
 // unavailable server is a chip of its own with its own translated reason, never a shorter list of
 // the wired ones: "absent" and "zero" must not render the same.
 //
+// The wired half carries a SECOND answer when the run's harness reported one: what the agent's
+// CLI said about each server when it started up. The two are deliberately not merged into one
+// status — the platform withholding a tool and the CLI failing to start one are different faults
+// for different people — and the absence of a CLI report renders as nothing at all, because
+// "nobody looked" and "the CLI loaded nothing" are opposite facts and only silence states the
+// first one honestly (a codex run, an older image and an unmapped runner pool all reach it).
+//
 // SELF-HIDING when the record holds nothing, like the sibling panels around it. The record is
 // written on EVERY container dispatch, so both lists empty is the state of every step on every
 // deployment that registers no tool servers at all — the overwhelming default. That state is a
@@ -16,7 +23,14 @@
 // section on every step of every run to say nothing happened. The distinction absent-vs-empty is
 // still carried on the wire and answered by the debug API, which is where a reader asking it looks.
 import type { StepToolServers } from '~/types/toolServers'
-import { reasonText, remedyText } from '~/components/panels/StepToolServers.logic'
+import {
+  observationFor,
+  observationIsFault,
+  observationText,
+  reasonText,
+  remedyText,
+  unattributedObservations,
+} from '~/components/panels/StepToolServers.logic'
 import { agentKindMeta } from '~/utils/catalog'
 
 const props = defineProps<{
@@ -33,8 +47,22 @@ const props = defineProps<{
 
 const { t } = useI18n()
 
+/**
+ * Servers the CLI named that this dispatch did not wire. Empty on every ordinary run (the CLI runs
+ * under `--strict-mcp-config`), and surfaced rather than filtered because the only way to reach it
+ * is a report that describes some other job — which must not be presented as this job's clean bill
+ * of health.
+ */
+const unattributed = computed(() => unattributedObservations(props.toolServers))
+
 const hasAny = computed(
-  () => props.toolServers.wired.length > 0 || props.toolServers.unavailable.length > 0,
+  () =>
+    props.toolServers.wired.length > 0 ||
+    props.toolServers.unavailable.length > 0 ||
+    // A report about servers this dispatch did not wire is the one thing worth showing on an
+    // otherwise empty record: both lists empty says the dispatched kind declared none, and a CLI
+    // naming servers anyway contradicts exactly that.
+    unattributed.value.length > 0,
 )
 
 /** Set only when a helper re-dispatch owns this record, so the ordinary case renders no extra line. */
@@ -44,6 +72,22 @@ const dispatchedAs = computed(() =>
     : null,
 )
 
+/**
+ * Each wired server with the CLI's own verdict joined onto it, when a verdict was reported. Bound
+ * here for the same reason `drops` is: the join and the absent-vs-not-loaded decision are pure and
+ * assertable without mounting, and resolving them once per record beats once per re-render.
+ */
+const wired = computed(() =>
+  props.toolServers.wired.map((server) => {
+    const observation = observationFor(props.toolServers.observed, server.id)
+    return {
+      ...server,
+      observedText: observationText(observation, (key, params) => t(key, params ?? {})),
+      isFault: observationIsFault(observation),
+    }
+  }),
+)
+
 /**
  * Each dropped server with both halves of its answer resolved: WHY it was dropped, and what to
  * change so the next run gets it. Bound here rather than called from the template so the pure
@@ -80,20 +124,59 @@ const drops = computed(() =>
       {{ t('panels.stepDetail.toolServers.dispatchedAs', { agent: dispatchedAs }) }}
     </p>
 
-    <ul v-if="toolServers.wired.length" class="flex flex-wrap gap-1.5">
+    <ul v-if="wired.length" class="flex flex-wrap gap-1.5">
       <li
-        v-for="server in toolServers.wired"
+        v-for="server in wired"
         :key="server.id"
         data-testid="step-tool-server-wired"
-        class="inline-flex items-center gap-1.5 rounded-full border border-emerald-500/30 bg-emerald-500/10 px-2 py-0.5 text-[12px] text-emerald-200"
+        :data-observed-fault="server.isFault ? 'true' : undefined"
+        class="inline-flex items-center gap-1.5 rounded-full border px-2 py-0.5 text-[12px]"
+        :class="
+          server.isFault
+            ? 'border-amber-500/30 bg-amber-500/10 text-amber-200'
+            : 'border-emerald-500/30 bg-emerald-500/10 text-emerald-200'
+        "
         :title="
           server.tools?.length
             ? t('panels.stepDetail.toolServers.narrowed', { tools: server.tools.join(', ') })
             : t('panels.stepDetail.toolServers.allTools')
         "
       >
-        <UIcon name="i-lucide-check" class="h-3.5 w-3.5" />
+        <UIcon
+          :name="server.isFault ? 'i-lucide-triangle-alert' : 'i-lucide-check'"
+          class="h-3.5 w-3.5"
+        />
         <span>{{ server.label || server.id }}</span>
+        <!--
+          The CLI's own verdict, when the run's harness reported one. Absent renders NOTHING: a
+          harness that publishes no report has said nothing about this server, and a placeholder
+          would read as a verdict.
+        -->
+        <span
+          v-if="server.observedText"
+          data-testid="step-tool-server-observed"
+          class="opacity-80"
+          >{{ server.observedText }}</span
+        >
+      </li>
+    </ul>
+
+    <!--
+      A report naming servers this dispatch did not wire can only come from a producer describing
+      some other job (a runner-pool manifest mapped at the wrong field). Stated rather than
+      filtered, so the rest of the report is not read as authoritative about this run.
+    -->
+    <ul v-if="unattributed.length" class="mt-2 space-y-1.5">
+      <li
+        v-for="server in unattributed"
+        :key="server.id"
+        data-testid="step-tool-server-unattributed"
+        class="flex items-start gap-1.5 text-[12px] text-slate-400"
+      >
+        <UIcon name="i-lucide-circle-help" class="mt-0.5 h-3.5 w-3.5 shrink-0" />
+        <span>{{
+          t('panels.stepDetail.toolServers.observed.unattributed', { id: server.id })
+        }}</span>
       </li>
     </ul>