@skyhook-io/radar-app 1.14.2 → 1.14.4

package/src/components/diagnose/InvestigationView.tsx

@@ -43,7 +43,7 @@ import {
   canInvestigateFurther,
 } from "./investigationState";
 import type { AssessmentExplanation } from "./parts";
-import { describeToolCall } from "./toolCallLabel";
+import { investigationRunningLabel } from "./toolCallLabel";
 import { AGENT_ROLE_LABELS } from "./AgentCase";
 import {
   Fragment,
@@ -99,9 +99,9 @@ import {
 import { resolveInvestigationCase } from "./investigationCase";
 import {
   InvestigationEvidencePane,
-  partitionInvestigationEvidence,
   type InvestigationTimelineScope,
 } from "./InvestigationEvidencePane";
+import { partitionInvestigationEvidence } from "./investigationEvidencePartition";
 import type { DiagnosisResourceRef } from "./diagnoseEvidenceTypes";
 import { formatInvestigationTarget } from "./target";
 import { parseContextName } from "../../utils/context-name";
@@ -176,19 +176,17 @@ export function InvestigationView({
   onOpenTimeline?: (scope: InvestigationTimelineScope) => void;
 }) {
   const { kind, namespace, name } = run;
-  // Apply is off for hosted agents (read-only server-side). Keyed on the selected
-  // agent, which matches run.agent unless a deployment mixes hosted + local agents.
-  const {
-    refreshRuns,
-    openInvestigation,
-    startError,
-    dismissError,
-    hosted,
-    agents,
-  } = useDiagnose();
-  const explanationEnabled = supportsAssessmentExplanation(
-    agents.find((agent) => agent.name === run.agent),
-  );
+  const { refreshRuns, openInvestigation, startError, dismissError, agents } =
+    useDiagnose();
+  // Capabilities are the declared ones of the agent that ran this run, not
+  // the picker's: a reopened run keeps the backend it was made with.
+  const runAgent = agents.find((agent) => agent.name === run.agent);
+  const explanationEnabled = supportsAssessmentExplanation(runAgent);
+  const canApply = runAgent?.apply === true;
+  // Read through a ref by the stream callback, which lives as long as the
+  // run and would otherwise keep the value from before the agents loaded.
+  const verifiesAfterApplyRef = useRef(false);
+  verifiesAfterApplyRef.current = runAgent?.verification === true;
   // Investigate again means look again, so it asks for a new session explicitly and only
   // carries the issue forward — being handed the previous answer is the one
   // thing someone clicking this doesn't want.
@@ -536,10 +534,13 @@ export function InvestigationView({
               });
               pendingApplyStartedLiveRef.current = false;
               if (effects.refreshClusterState) refreshClusterState();
-              // A successful apply is one compound server-owned job. Its next
-              // durable event is the automatic read-only verification turn; hold
-              // the controls through that adjacent event so there is no idle flash.
-              if (effects.verificationPending) setVerificationPending(true);
+              // On a backend that verifies, a successful apply is one compound
+              // server-owned job whose next durable event is the automatic
+              // read-only verification turn; hold the controls through that
+              // adjacent event so there is no idle flash. A backend that
+              // declares no verification sends no such turn, so nothing waits.
+              if (effects.verificationPending && verifiesAfterApplyRef.current)
+                setVerificationPending(true);
             }
             if (live || (isApply && applyStartedLive)) refreshRuns();
             break;
@@ -1299,13 +1300,15 @@ export function InvestigationView({
     (rootCauseEvidenceResolution?.links.length ||
       investigationCase?.items.length ||
       currentAssessment.diagnosis.unlinkedEvidence ||
-      currentAssessment.diagnosis.evidenceMalformed) ? (
+      currentAssessment.diagnosis.evidenceMalformed ||
+      currentAssessment.diagnosis.omittedEntries) ? (
       <AssessmentSources
         renderedGroupIds={visibleEvidenceGroupIds}
         resolution={rootCauseEvidenceResolution}
         investigationCase={investigationCase}
         unlinkedEvidence={currentAssessment.diagnosis.unlinkedEvidence}
         evidenceMalformed={currentAssessment.diagnosis.evidenceMalformed}
+        omittedEntries={currentAssessment.diagnosis.omittedEntries}
         onViewSource={viewActivitySource}
       />
     ) : undefined;
@@ -1313,7 +1316,8 @@ export function InvestigationView({
     storyShape &&
     (investigationCase?.items.some((item) => item.placement === "source") ||
       currentAssessment?.diagnosis?.unlinkedEvidence ||
-      currentAssessment?.diagnosis?.evidenceMalformed)
+      currentAssessment?.diagnosis?.evidenceMalformed ||
+      currentAssessment?.diagnosis?.omittedEntries)
       ? assessmentSourcesNode
       : undefined;
   const assessmentLimits = useMemo(() => {
@@ -1345,8 +1349,7 @@ export function InvestigationView({
   );
   // While the first assessment is still running the pane keeps the story
   // shape, so the page fills in rather than rearranging when the verdict lands.
-  const storyShell =
-    !hosted && !currentAssessment && lastTurn?.status === "running";
+  const storyShell = !currentAssessment && lastTurn?.status === "running";
   const currentAssessmentEvidenceConflict =
     currentAssessment?.diagnosis?.healthy === true &&
     investigationEvidenceConflictsWithHealthy(projection);
@@ -1458,37 +1461,20 @@ export function InvestigationView({
     toolSeenRef.current = toolSignature;
     toolChangedAtRef.current = Date.now();
   }, [toolSignature]);
-  const investigatingLabel = (() => {
-    const items = lastTurn?.timeline ?? [];
-    const reads = items.filter((item) => item.kind === "tool").length;
+  const investigatingLabel = investigationRunningLabel({
+    lastTool: lastTool && lastTool.kind === "tool" ? lastTool : undefined,
+    reads: (lastTurn?.timeline ?? []).filter((item) => item.kind === "tool")
+      .length,
     // The render that first shows a changed tool is not quiet yet; the effect
     // that stamps the change runs after it.
-    const quietFor =
+    quietFor:
       toolSeenRef.current === toolSignature
         ? Date.now() - toolChangedAtRef.current
-        : 0;
-    let current = "Investigating";
-    if (lastTool && lastTool.kind === "tool" && lastTool.tool) {
-      current =
-        lastTool.status === "running" || quietFor < 8000
-          ? describeToolCall(lastTool.tool, lastTool.summary)
-          : "Thinking";
-    }
-    const elapsed = runningSinceRef.current
+        : 0,
+    elapsedSeconds: runningSinceRef.current
       ? Math.round((Date.now() - runningSinceRef.current) / 1000)
-      : 0;
-    // The tool text changes width as it changes; the counters sit apart on
-    // the right so they never move with it.
-    return {
-      current: `${current}…`,
-      meta: [
-        reads > 0 ? `${reads} ${reads === 1 ? "read" : "reads"}` : undefined,
-        elapsed >= 2 ? `${elapsed} s` : undefined,
-      ]
-        .filter(Boolean)
-        .join(" · "),
-    };
-  })();
+      : 0,
+  });
   const showSplitWorkspace = maximized;
   const splitGridClass = showSplitWorkspace
     ? "@min-[1000px]/investigation:grid-cols-[minmax(320px,min(30%,520px))_minmax(0,1fr)]"
@@ -1677,7 +1663,7 @@ export function InvestigationView({
               lastApplyAttemptIdx,
               localApplyAttemptAssessmentIdx,
               interactionsBlocked,
-              hosted,
+              canApply,
               hasNewerEvidence: hasEvidenceCollectedAfterAssessment,
             })
               ? requestApply
@@ -1983,7 +1969,8 @@ export function InvestigationView({
                             return turnCase.items.length ||
                               turnResolution?.links.length ||
                               turn.diagnosis.unlinkedEvidence ||
-                              turn.diagnosis.evidenceMalformed ? (
+                              turn.diagnosis.evidenceMalformed ||
+                              turn.diagnosis.omittedEntries ? (
                               <AssessmentSources
                                 renderedGroupIds={visibleEvidenceGroupIds}
                                 resolution={turnResolution}
@@ -1994,6 +1981,7 @@ export function InvestigationView({
                                 evidenceMalformed={
                                   turn.diagnosis.evidenceMalformed
                                 }
+                                omittedEntries={turn.diagnosis.omittedEntries}
                                 readOnly
                                 onViewSource={viewActivitySource}
                               />

package/src/components/diagnose/StoryExcerpt.tsx

@@ -0,0 +1,118 @@
+import { clsx } from "clsx";
+import {
+  Collapse,
+  TerminalBlock,
+  TerminalBlockLabel,
+} from "@skyhook-io/k8s-ui";
+import { InventoryRow } from "./investigationEvidence/bodies/inventory";
+import { RankingRow } from "./investigationEvidence/bodies/ranking";
+import { PostureFindingRow } from "./investigationEvidence/bodies/posture";
+import { MetricsBody } from "./investigationEvidence/bodies/metrics";
+import type { StoryExcerpt as Excerpt } from "./investigationEvidence/excerpt";
+import type { InvestigationEvidenceData } from "./investigationEvidence";
+import type { MetricsChangeCoverage } from "./investigationMetrics";
+
+/** The inline slice of a placed card, rendered from Radar's record. */
+export function StoryExcerpt({
+  excerpt,
+  data,
+  prominence,
+  open,
+  canExpand,
+  changeCoverage,
+}: {
+  excerpt: Excerpt;
+  data: InvestigationEvidenceData;
+  prominence: "primary" | "supporting" | "secondary";
+  open: boolean;
+  canExpand: boolean;
+  changeCoverage?: MetricsChangeCoverage;
+}) {
+  const padding = prominence === "primary" ? "px-3 pb-2.5" : "px-2.5 pb-2";
+  switch (excerpt.kind) {
+    case "lines":
+      return (
+        <div data-story-log-lines className={padding}>
+          <TerminalBlock
+            footer={
+              excerpt.rest.length > 0 ? (
+                <Collapse open={open && canExpand}>
+                  <TerminalBlockLabel divider>Earlier lines</TerminalBlockLabel>
+                  <pre className="overflow-x-auto whitespace-pre-wrap break-words px-3 pb-2.5 font-mono text-xs leading-relaxed text-[var(--terminal-text)]">
+                    {excerpt.rest.join("\n")}
+                  </pre>
+                </Collapse>
+              ) : null
+            }
+          >
+            {excerpt.head.join("\n")}
+          </TerminalBlock>
+        </div>
+      );
+    case "rows":
+      return (
+        <div data-story-inventory-rows className={padding}>
+          <div className="rounded-md border border-theme-border">
+            {excerpt.entries.map((entry, index) =>
+              entry.row ? (
+                <InventoryRow
+                  key={entry.key}
+                  resource={entry.row}
+                  divider={index > 0}
+                />
+              ) : (
+                <p
+                  key={entry.key}
+                  data-story-inventory-absent={
+                    entry.matches === 0 ? "" : undefined
+                  }
+                  className={clsx(
+                    "px-2.5 py-1.5 font-mono text-xs text-theme-text-secondary",
+                    index > 0 && "border-t border-theme-border/60",
+                  )}
+                >
+                  {entry.matches === 0
+                    ? `Not in this listing: ${entry.label}`
+                    : `${entry.label}: ${entry.matches} entries match in this listing`}
+                </p>
+              ),
+            )}
+          </div>
+        </div>
+      );
+    case "ranking":
+      return (
+        <div data-story-ranking-rows className={padding}>
+          <div className="rounded-md border border-theme-border">
+            {excerpt.rows.map((row, index) => (
+              <RankingRow
+                key={`${row.namespace ?? ""}/${row.name}`}
+                row={row}
+                divider={index > 0}
+              />
+            ))}
+          </div>
+        </div>
+      );
+    case "posture":
+      return (
+        <div data-story-posture-findings className={padding}>
+          <div className="rounded-md border border-theme-border">
+            {excerpt.findings.map((finding, index) => (
+              <PostureFindingRow
+                key={`${finding.name}-${finding.check}`}
+                finding={finding}
+                divider={index > 0}
+              />
+            ))}
+          </div>
+        </div>
+      );
+    case "chart":
+      return data.type === "metrics" ? (
+        <div data-story-metrics className={padding}>
+          <MetricsBody data={data} changeCoverage={changeCoverage} />
+        </div>
+      ) : null;
+  }
+}

package/src/components/diagnose/assessmentCopy.ts

@@ -0,0 +1,169 @@
+import type { Diagnosis } from "../../api/diagnose";
+import { storyPlainText } from "./investigationStory";
+
+/**
+ * The whole assessment as text: headline, certainty, what is unresolved, the
+ * technical cause, the story without its markers, and the steps. Copying only
+ * the headline would ship the persuasive half without its caveats.
+ */
+/** What Radar adds to the agent's verdict when the assessment is copied for a channel. */
+export interface AssessmentCopyRadar {
+  /** Reads Radar could not complete, as shown in Still open. */
+  limits?: readonly string[];
+  /** Adverse Radar cards the agent explained, as shown in Still open. */
+  signals?: readonly string[];
+  /** Adverse Radar cards nothing explains, as shown above a healthy verdict. */
+  flags?: readonly string[];
+  /** Where and when: the header line a reader in a channel needs first. */
+  context?: {
+    target: string;
+    cluster?: string;
+    startedAt?: string;
+    agent?: string;
+  };
+  /** The placed cards, as short excerpts: the receipts behind the headline. */
+  receipts?: readonly {
+    title: string;
+    role?: string;
+    lines: readonly string[];
+    /** The agent's statement of what this result does not cover. */
+    gap?: string;
+  }[];
+}
+
+/**
+ * The assessment as Markdown for a channel or a ticket: context, headline,
+ * cause, the receipts, what is still open, the next step. The full story and
+ * every captured result stay in Radar; the text says so.
+ */
+export function assessmentCopyText(
+  diagnosis: Diagnosis,
+  radar: AssessmentCopyRadar = {},
+): string {
+  const parts: string[] = [];
+  if (radar.context) {
+    const when = radar.context.startedAt
+      ? new Date(radar.context.startedAt).toLocaleString(undefined, {
+          dateStyle: "medium",
+          timeStyle: "short",
+        })
+      : undefined;
+    parts.push(
+      [
+        `**${radar.context.target}**`,
+        radar.context.cluster,
+        when,
+        radar.context.agent ? `via ${radar.context.agent}` : undefined,
+      ]
+        .filter(Boolean)
+        .join(" · "),
+    );
+  }
+  if (diagnosis.summary) {
+    const certainty = diagnosis.healthy
+      ? "Healthy"
+      : diagnosis.certainty
+        ? CERTAINTY_LABEL[diagnosis.certainty]
+        : undefined;
+    parts.push(
+      `**${diagnosis.summary.trim()}**${certainty ? ` — ${certainty} (agent's word)` : ""}`,
+    );
+  } else if (diagnosis.certainty) {
+    parts.push(`Certainty (agent): ${CERTAINTY_LABEL[diagnosis.certainty]}`);
+  }
+  // The pasted text must not read more confident than the screen: Radar's
+  // own qualifications travel with the agent's.
+  const flags = (radar.flags ?? []).filter((item) => item.trim());
+  if (flags.length > 0)
+    parts.push(
+      [
+        "Radar flagged:",
+        ...flags.map((item) => `- ${item}`),
+        "Read those cards before treating this as an all-clear.",
+      ].join("\n"),
+    );
+  const unresolved = [
+    ...(diagnosis.unresolved ?? []),
+    ...(radar.limits ?? []),
+    ...(radar.signals ?? []),
+  ].filter((item) => item.trim());
+  if (unresolved.length > 0)
+    parts.push(
+      ["Still open:", ...unresolved.map((item) => `- ${item}`)].join("\n"),
+    );
+  if (diagnosis.rootCause) parts.push(storyPlainText(diagnosis.rootCause));
+  const receipts = (radar.receipts ?? []).filter((receipt) => receipt.title);
+  if (receipts.length > 0) {
+    parts.push(
+      [
+        "Evidence (Radar):",
+        ...receipts.map((receipt) =>
+          [
+            `- **${receipt.title}**${receipt.role ? ` · ${receipt.role}` : ""}`,
+            ...receipt.lines
+              .filter((line) => line.trim())
+              .map((line) => `  > ${line.trim()}`),
+            ...(receipt.gap ? [`  Not shown: ${receipt.gap}`] : []),
+          ].join("\n"),
+        ),
+      ].join("\n"),
+    );
+  } else if (!radar.context) {
+    const story = storyPlainText(diagnosis.report ?? "");
+    if (story) parts.push(story);
+  }
+  const steps = diagnosis.steps?.length
+    ? diagnosis.steps.map(
+        (step, index) =>
+          `${index + 1}. [${STEP_KIND_LABEL[step.kind]}] ${step.text}${step.precondition ? ` (only if ${step.precondition})` : ""}`,
+      )
+    : (diagnosis.remediation ?? []).map(
+        (text, index) => `${index + 1}. ${text}`,
+      );
+  if (steps.length > 0) {
+    if (radar.context) {
+      // A channel gets the recommended step; the rest wait in Radar.
+      const lead = diagnosis.recommendedIndex
+        ? diagnosis.recommendedIndex - 1
+        : 0;
+      const first = steps[lead] ?? steps[0];
+      const rest = steps.length - 1;
+      parts.push(
+        [
+          `Next step: ${first.replace(/^\d+\. /, "")}`,
+          diagnosis.recommendedReason
+            ? `Why: ${diagnosis.recommendedReason}`
+            : undefined,
+          rest > 0
+            ? `${rest} more ${rest === 1 ? "step" : "steps"} in Radar.`
+            : undefined,
+        ]
+          .filter(Boolean)
+          .join("\n"),
+      );
+    } else parts.push(["Next steps:", ...steps].join("\n"));
+  }
+  if (radar.context)
+    parts.push(
+      "Full analysis and every captured result: open the investigation in Radar.",
+    );
+  return parts.join("\n\n");
+}
+
+export const CERTAINTY_LABEL: Record<
+  NonNullable<Diagnosis["certainty"]>,
+  string
+> = {
+  established: "Established",
+  likely: "Likely",
+  suspected: "Suspected",
+};
+
+export const STEP_KIND_LABEL: Record<
+  NonNullable<Diagnosis["steps"]>[number]["kind"],
+  string
+> = {
+  mitigate: "Mitigate",
+  verify: "Verify",
+  investigate: "Investigate",
+};