@skyhook-io/radar-app 1.14.2 → 1.14.3

package/src/components/diagnose/investigationEvidence/types.ts

@@ -69,7 +69,9 @@ export type InvestigationEvidenceKind =
   | "alerts"
   | "helm"
   | "permissions"
-  | "metrics";
+  | "metrics"
+  | "ranking"
+  | "posture";
 export type InvestigationSemanticDomain = "issue" | "startup" | "crash" | "dns";
 export interface InvestigationEvidenceSource {
   /** DOM-safe stable identity derived from turn index + the agent step ID. */
@@ -138,6 +140,8 @@ export interface InvestigationResourceSummary {
   name: string;
   namespace?: string;
   status?: string;
+  /** For a search hit: the field that matched and the text around it. */
+  match?: string;
   ready?: string;
   issue?: string;
   age?: string;
@@ -265,6 +269,74 @@ export interface InvestigationHelmRelease {
   managedByFluxHelmRelease?: string;
   lastOperation?: InvestigationHelmOperation;
   resources: InvestigationHelmOwnedResource[];
+  /** Newest first; the tool returns the release's stored revisions. */
+  history?: InvestigationHelmRevision[];
+  hooks?: InvestigationHelmHook[];
+  /** User-supplied values as the tool returned them, secrets already redacted. */
+  values?: Record<string, unknown>;
+}
+export interface InvestigationHelmRevision {
+  revision: number;
+  status: string;
+  chart: string;
+  appVersion?: string;
+  description?: string;
+  updated: string;
+}
+export interface InvestigationHelmHook {
+  name: string;
+  kind: string;
+  namespace?: string;
+  events: string[];
+  weight: number;
+  status?: string;
+  startedAt?: string;
+  completedAt?: string;
+}
+/** One row of a live-metrics ranking, as the tool returned it. */
+export interface InvestigationRankingRow {
+  kind: string;
+  namespace?: string;
+  name: string;
+  cpu: string;
+  memory: string;
+  cpuLimit?: string;
+  memoryLimit?: string;
+  restarts?: number;
+  ready?: string;
+  status?: string;
+  /** The investigated resource itself, or one of its own pods. */
+  target: boolean;
+  /** The workload a ranked pod belongs to, when the tool reports one. */
+  owner?: { kind: string; group?: string; namespace?: string; name: string };
+}
+/** A configuration or upgrade finding about one resource. */
+export interface InvestigationPostureFinding {
+  kind: string;
+  group?: string;
+  namespace?: string;
+  name: string;
+  check: string;
+  severity: string;
+  category?: string;
+  message: string;
+  remediation?: string;
+  /** The investigated resource itself. */
+  target: boolean;
+  /** The workload that owns the finding's resource, when the scan names one. */
+  managedBy?: {
+    kind: string;
+    group?: string;
+    namespace?: string;
+    name: string;
+  };
+}
+export interface InvestigationPermissionRule {
+  verbs: string[];
+  apiGroups: string[];
+  resources: string[];
+  resourceNames?: string[];
+  nonResourceURLs?: string[];
 }
 export interface InvestigationPermissionSubject {
   kind: string;
@@ -377,10 +449,31 @@ export type InvestigationEvidenceData =
       resources: InvestigationResourceSummary[];
       scope: string;
     }
+  | {
+      type: "ranking";
+      /** What was ranked: pods, workloads or nodes. */
+      kind: string;
+      sort: string;
+      rows: InvestigationRankingRow[];
+      scope: string;
+    }
+  | {
+      type: "posture";
+      source: "audit" | "upgrade";
+      findings: InvestigationPostureFinding[];
+      scope: string;
+    }
   | {
       type: "receipt";
       checked:
-        "issues" | "events" | "changes" | "inventory" | "logs" | "alerts";
+        | "issues"
+        | "events"
+        | "changes"
+        | "inventory"
+        | "logs"
+        | "alerts"
+        | "metrics"
+        | "posture";
       scope: string;
       /**
        * Only when there is something to add. The card already shows the title
@@ -405,6 +498,8 @@ export type InvestigationEvidenceData =
       /** Present for the subject-permissions response shape. */
       bindings?: InvestigationPermissionBinding[];
       flatRulesCount?: number;
+      /** The effective rules themselves, up to the tool's cap. */
+      rules?: InvestigationPermissionRule[];
       truncated?: boolean;
       usedByPods?: string[];
       podsTotal?: number;

package/src/components/diagnose/investigationEvidenceKinds.ts

@@ -14,6 +14,8 @@ import {
   Package,
   ScrollText,
   ShieldAlert,
+  ShieldCheck,
+  BarChart3,
   type LucideIcon,
 } from "lucide-react";
 
@@ -154,6 +156,26 @@ export const EVIDENCE_KIND_TRAITS: Readonly<
     icon: ListTree,
     caveat: undefined,
   },
+  // A ranking is live numbers at the moment of the read; the target's own row
+  // is a fact about it, the rest is where it stands among neighbours.
+  ranking: {
+    adverse: false,
+    focused: false,
+    fullRow: true,
+    icon: BarChart3,
+    caveat:
+      "Ranked by live metrics at the moment of the read; a position is not a cause.",
+  },
+  // Posture findings are configuration checks, never an active failure; they
+  // stay in their own lane so a check is not read as an outage.
+  posture: {
+    adverse: false,
+    focused: false,
+    fullRow: true,
+    icon: ShieldCheck,
+    caveat:
+      "Posture findings are configuration checks, not evidence of an active failure.",
+  },
   // A receipt records a check that found nothing, so it can never contradict.
   receipt: {
     adverse: false,

package/src/components/diagnose/investigationEvidencePartition.ts

@@ -0,0 +1,296 @@
+import {
+  EVIDENCE_KIND_TRAITS,
+  evidenceKindIsFocused,
+} from "./investigationEvidenceKinds";
+import { evidenceDisplaySnapshot } from "./investigationEvidencePresentation";
+import {
+  investigationSourceArgs,
+  type InvestigationEvidenceData,
+  type InvestigationEvidenceGroup,
+  type InvestigationEvidenceObservation,
+  type InvestigationEvidenceProjection,
+  type InvestigationRootCauseEvidenceResolution,
+  type InvestigationEvidenceSource,
+} from "./investigationEvidence";
+import type {
+  InvestigationCaseItem,
+  InvestigationCaseResolution,
+} from "./investigationCase";
+import type { DiagnosisEvidenceRole } from "../../api/diagnose";
+
+/** Item identity for the excluded-hypothesis lookup; index alone repeats across turns. */
+export function investigationCaseItemKey(item: InvestigationCaseItem): string {
+  return `${item.source.id}\u0000${item.index}`;
+}
+
+const EVIDENCE_ROLE_RANK: Readonly<Record<DiagnosisEvidenceRole, number>> = {
+  cause: 0,
+  symptom: 1,
+  // A ruled-out card keeps Radar's place in the list; the role only labels it.
+  rules_out: 2,
+  context: 3,
+  benign: 4,
+  demoted: 5,
+};
+
+const UNLABELLED_RANK = 2;
+
+function sourceNamesOneResource(source: InvestigationEvidenceSource): boolean {
+  const args = investigationSourceArgs(source);
+  return (
+    typeof args?.kind === "string" &&
+    args.kind !== "" &&
+    typeof args.name === "string" &&
+    args.name !== ""
+  );
+}
+
+export function investigationCaseByGroup(
+  investigationCase?: InvestigationCaseResolution,
+): Map<string, InvestigationCaseItem[]> {
+  const byGroup = new Map<string, InvestigationCaseItem[]>();
+  for (const item of investigationCase?.items ?? []) {
+    if (!item.groupId || item.placement === "source") continue;
+    const items = byGroup.get(item.groupId) ?? [];
+    items.push(item);
+    byGroup.set(item.groupId, items);
+  }
+  return byGroup;
+}
+
+export function evidenceTypePrefersFullRow(
+  type: InvestigationEvidenceData["type"],
+): boolean {
+  return EVIDENCE_KIND_TRAITS[type].fullRow;
+}
+
+// Supporting evidence becomes a two-column grid when the pane is wide enough.
+// Keep compact cards paired only with an adjacent compact card. Otherwise a
+// full-row card between them strands a conspicuous empty half-row (and makes the
+// visual order look accidental), as does an odd card at the end of a run.
+export function investigationEvidenceFullRowFlags(
+  types: readonly InvestigationEvidenceData["type"][],
+): boolean[] {
+  const fullRow = types.map(evidenceTypePrefersFullRow);
+  let compactRunStart = 0;
+
+  for (let index = 0; index <= types.length; index += 1) {
+    if (index < types.length && !fullRow[index]) continue;
+    const compactRunLength = index - compactRunStart;
+    if (compactRunLength % 2 === 1) fullRow[index - 1] = true;
+    compactRunStart = index + 1;
+  }
+
+  return fullRow;
+}
+
+type EvidenceCollection = "main" | "workload" | "earlier";
+
+export function partitionInvestigationEvidence(
+  groups: InvestigationEvidenceGroup[],
+  resolution?: InvestigationRootCauseEvidenceResolution,
+  investigationCase?: InvestigationCaseResolution,
+  /**
+   * Under a story every captured result about the target belongs in the one
+   * inventory the reader opens to see what Radar recorded; nothing about the
+   * target is folded into a second tier. Broader results stay cited-only.
+   */
+  inventory = false,
+) {
+  // Selection: legacy root-cause links plus every placed agent item, of any
+  // role (placement promotes a group into main the way a citation does; the
+  // role does not matter here). Ordering below is the only place roles act,
+  // and nothing the agent sends can remove a group from a collection.
+  const caseByGroup = investigationCaseByGroup(investigationCase);
+  const selected = new Set([
+    ...(resolution?.status === "linked"
+      ? resolution.links.map((link) => link.originalGroupId)
+      : []),
+    ...caseByGroup.keys(),
+  ]);
+  const collections: Record<EvidenceCollection, InvestigationEvidenceGroup[]> =
+    {
+      main: [],
+      workload: [],
+      earlier: [],
+    };
+  const collectionByGroup = new Map<string, EvidenceCollection>();
+  const adverse = (group: InvestigationEvidenceGroup) =>
+    ["error", "alert", "warning"].includes(group.latest.tone);
+  // Broader cards are facts about something other than the target. They are
+  // withheld unless cited, and the pane says how many were withheld so a
+  // reader knows the agent looked at things it did not build its case on.
+  let hiddenBroader = 0;
+  // Broader metrics are facts about something other than the target. They are
+  // withheld unless cited, and the pane says how many were withheld so a
+  // reader knows the agent ran queries it did not build its case on.
+  let hiddenMetrics = 0;
+  for (const group of groups) {
+    const broader = group.latest.relevance === "broader";
+    // Citations select tool results, not individual rows in a broad search.
+    // Only a focused, unambiguous fact can be promoted by a source citation.
+    // An agent item names this observation when its subject does, or when the
+    // call it cites was itself scoped to one resource; a subject-less item on
+    // a broad query only proves the query returned one row and is gated like
+    // a citation of its source.
+    const namedByAgent = (caseByGroup.get(group.id) ?? []).some(
+      (item) => item.subject || sourceNamesOneResource(item.source),
+    );
+    if (broader && !namedByAgent) {
+      const citingSource =
+        resolution?.links.find((item) => item.originalGroupId === group.id)
+          ?.source ?? caseByGroup.get(group.id)?.[0]?.source;
+      const focused = evidenceKindIsFocused(group.latest.data.type);
+      const sourceGroups = citingSource
+        ? groups.filter(
+            (candidate) =>
+              evidenceKindIsFocused(candidate.latest.data.type) &&
+              candidate.observations.some(
+                (observation) => observation.source.id === citingSource.id,
+              ),
+          )
+        : [];
+      if (!selected.has(group.id) || !focused || sourceGroups.length !== 1) {
+        // The two counts head separate lines in the pane, so they have to be
+        // disjoint: a withheld chart announced by both would read as two
+        // withheld results.
+        if (!group.historical) {
+          if (group.latest.data.type === "metrics") hiddenMetrics += 1;
+          else hiddenBroader += 1;
+        }
+        continue;
+      }
+    }
+    const main =
+      !group.historical &&
+      (selected.has(group.id) ||
+        (!broader &&
+          (inventory ||
+            group.latest.tier === "key" ||
+            (group.latest.tier === "supporting" && adverse(group)))));
+    const collection = main
+      ? "main"
+      : group.historical
+        ? "earlier"
+        : "workload";
+    collections[collection].push(group);
+    collectionByGroup.set(group.id, collection);
+  }
+  // A group takes its strongest role (lowest rank); within one role the
+  // agent's own item order decides. Unlabelled and ruled-out groups keep
+  // Radar's order among themselves.
+  const roleOrder = (group: InvestigationEvidenceGroup) => {
+    let rank: number | undefined;
+    let itemIndex = Number.POSITIVE_INFINITY;
+    for (const item of caseByGroup.get(group.id) ?? []) {
+      const itemRank = EVIDENCE_ROLE_RANK[item.role];
+      if (rank === undefined || itemRank < rank) {
+        rank = itemRank;
+        itemIndex = item.index;
+      } else if (itemRank === rank) {
+        itemIndex = Math.min(itemIndex, item.index);
+      }
+    }
+    if (rank === undefined || rank === UNLABELLED_RANK) {
+      return { rank: UNLABELLED_RANK, itemIndex: Number.POSITIVE_INFINITY };
+    }
+    return { rank, itemIndex };
+  };
+  collections.main.sort((left, right) => {
+    const leftRole = roleOrder(left);
+    const rightRole = roleOrder(right);
+    const agentOrder =
+      Number.isFinite(leftRole.itemIndex) ||
+      Number.isFinite(rightRole.itemIndex)
+        ? leftRole.itemIndex - rightRole.itemIndex
+        : 0;
+    return (
+      leftRole.rank - rightRole.rank ||
+      agentOrder ||
+      Number(right.latest.tier === "key") -
+        Number(left.latest.tier === "key") ||
+      Number(adverse(right)) - Number(adverse(left)) ||
+      left.firstOrder - right.firstOrder
+    );
+  });
+  // A healthy workload's collection opens with several "nothing here"
+  // receipts; the cards that carry facts (its vitals above all) come first,
+  // and the receipts keep their order among themselves.
+  collections.workload.sort(
+    (left, right) =>
+      Number(left.kind === "receipt") - Number(right.kind === "receipt"),
+  );
+  return { ...collections, collectionByGroup, hiddenBroader, hiddenMetrics };
+}
+
+export function investigationEvidenceRevealCollection(
+  projection: InvestigationEvidenceProjection,
+  sourceId: string,
+  partition = partitionInvestigationEvidence(projection.groups),
+): Exclude<EvidenceCollection, "main"> | "coverage" | undefined {
+  const source = projection.sources.find((item) => item.id === sourceId);
+  const collection = source?.primaryGroupId
+    ? partition.collectionByGroup.get(source.primaryGroupId)
+    : undefined;
+  if (collection) return collection === "main" ? undefined : collection;
+  if (
+    projection.limitations.some((limitation) =>
+      limitation.sources.some((source) => source.id === sourceId),
+    )
+  )
+    return "coverage";
+  return undefined;
+}
+
+export function previousDifferentObservations(
+  group: InvestigationEvidenceGroup,
+  citedOrder?: number,
+  boundOrders: ReadonlySet<number> = new Set(),
+) {
+  const seen = new Set([evidenceDisplaySnapshot(group.latest)]);
+  const pinned = (observation: InvestigationEvidenceObservation) =>
+    observation.source.order === citedOrder ||
+    boundOrders.has(observation.source.order);
+  return [...group.observations].reverse().filter((observation) => {
+    if (observation === group.latest) return false;
+    // An observation bound to an agent item always keeps its own row: display
+    // equivalence is a folding rule for unpinned rechecks, never a reason to
+    // move a claim onto different content.
+    if (boundOrders.has(observation.source.order)) return true;
+    // A pinned observation wins over an unpinned twin with the same display
+    // content.
+    if (
+      !pinned(observation) &&
+      group.observations.some(
+        (other) =>
+          pinned(other) &&
+          evidenceDisplaySnapshot(other) ===
+            evidenceDisplaySnapshot(observation),
+      )
+    )
+      return false;
+    const snapshot = evidenceDisplaySnapshot(observation);
+    if (seen.has(snapshot)) return false;
+    seen.add(snapshot);
+    return true;
+  });
+}
+
+export function investigationEvidenceShouldRevealHistory(
+  group: InvestigationEvidenceGroup,
+  sourceId?: string,
+  /** Sources whose observation carries an agent item and so always has a row. */
+  boundSourceIds: ReadonlySet<string> = new Set(),
+): boolean {
+  return (
+    Boolean(sourceId) &&
+    group.latest.source.id !== sourceId &&
+    group.observations.some(
+      (observation) =>
+        observation.source.id === sourceId &&
+        (boundSourceIds.has(observation.source.id) ||
+          evidenceDisplaySnapshot(observation) !==
+            evidenceDisplaySnapshot(group.latest)),
+    )
+  );
+}

package/src/components/diagnose/parts.test.tsx

@@ -1,4 +1,5 @@
 import { renderToStaticMarkup } from "react-dom/server";
+import { TW_EASE_UI } from "../../utils/animation";
 import { describe, expect, it, vi } from "vitest";
 import {
   AgentControls,
@@ -349,8 +350,9 @@ describe("Timeline reasoning density", () => {
     );
 
     expect(html).toContain("height:47px");
+    // The clamp animates on the shared disclosure clock, not a local timing.
     expect(html).toContain(
-      "transition-[height] duration-200 ease-out motion-reduce:transition-none",
+      `transition-[height] duration-300 ${TW_EASE_UI} motion-reduce:transition-none`,
     );
     expect(html).not.toContain("animate-transcript-enter");
     expect(html).not.toContain("Show reasoning");