@skyhook-io/radar-app 1.14.0 → 1.14.2

package/src/components/diagnose/investigationState.ts

@@ -1,5 +1,6 @@
 // Pure presentation decisions over the durable transcript and evidence projection.
 // Keep React/DOM orchestration in InvestigationView; these rules have no UI runtime.
+import { isDiagnosableWorkloadKind } from "./investigationEvidence/observations";
 import { evidenceKindIsAdverse } from "./investigationEvidenceKinds";
 import {
   DiagnoseError,
@@ -273,32 +274,130 @@ export function investigationEvidenceInputsEqual(
 }
 
 /**
- * The turn whose agent case annotates the Evidence pane. A follow-up answer
- * that cites evidence ("chart this and cite it") must reach Findings, so the
- * newest completed non-apply, non-explanation turn carrying a bound case or
- * linked root-cause refs wins; earlier turns keep their case read-only.
+ * Which turns are assessments — the ones Findings may show. The initial turn
+ * and explicit verifications always are; an ordinary question is one only
+ * when its verdict says so with `revisesAssessment` AND carries a complete
+ * verdict (a headline and a finding), because agents restate the root cause
+ * on most answers and a bare flag must never retire what the reader is
+ * looking at. The server enforces the same completeness rule; this mirrors it
+ * so a hosted backend that forgets cannot rewrite Findings by accident.
  */
-export function investigationLiveCaseTurnIndex(
+export function investigationIsAssessmentTurn(
+  turn: Pick<
+    Turn,
+    | "status"
+    | "apply"
+    | "explainAssessment"
+    | "question"
+    | "verify"
+    | "diagnosis"
+  >,
+): boolean {
+  const dx = turn.diagnosis;
+  if (!dx || turn.status !== "done" || turn.apply || turn.explainAssessment)
+    return false;
+  const structured =
+    !!dx.rootCause ||
+    (dx.remediation?.length ?? 0) > 0 ||
+    !!dx.healthy ||
+    !!dx.inconclusive;
+  if (!structured) return false;
+  if (!turn.question || turn.verify) return true;
+  return (
+    dx.revisesAssessment === true &&
+    !!dx.summary &&
+    (!!dx.rootCause || !!dx.healthy || !!dx.inconclusive)
+  );
+}
+
+/**
+ * Later turns whose reads do not make the assessment "earlier": a question
+ * the agent answered under the story contract and marked as not revising it.
+ * The contract is only in force when the assessment itself carries a summary;
+ * older runs never asked, so every later read still counts as newer evidence.
+ */
+export function investigationSettledAnswerTurnIndexes(
   turns: readonly Pick<
     Turn,
-    "status" | "apply" | "explainAssessment" | "diagnosis"
+    | "status"
+    | "apply"
+    | "explainAssessment"
+    | "question"
+    | "verify"
+    | "diagnosis"
   >[],
   currentAssessmentIdx: number,
-): number {
-  for (let index = turns.length - 1; index >= 0; index -= 1) {
-    const turn = turns[index];
-    if (turn.status !== "done" || turn.apply || turn.explainAssessment)
-      continue;
-    const diagnosis = turn.diagnosis;
-    if (!diagnosis) continue;
+): Set<number> {
+  const settled = new Set<number>();
+  const assessment = turns[currentAssessmentIdx]?.diagnosis;
+  if (!assessment?.summary) return settled;
+  turns.forEach((turn, index) => {
+    if (index <= currentAssessmentIdx) return;
     if (
-      diagnosis.evidence?.some((item) => item.status === "linked") ||
-      (diagnosis.rootCause && diagnosis.rootCauseEvidence?.status === "linked")
-    ) {
-      return Math.max(index, currentAssessmentIdx);
-    }
-  }
-  return currentAssessmentIdx;
+      turn.status === "done" &&
+      turn.diagnosis &&
+      !turn.apply &&
+      !turn.verify &&
+      !turn.explainAssessment &&
+      turn.diagnosis.revisesAssessment !== true
+    )
+      settled.add(index);
+  });
+  return settled;
+}
+
+export function investigationAssessmentTurnIndexes(
+  turns: readonly Pick<
+    Turn,
+    | "status"
+    | "apply"
+    | "explainAssessment"
+    | "question"
+    | "verify"
+    | "diagnosis"
+  >[],
+): number[] {
+  const indexes: number[] = [];
+  turns.forEach((turn, index) => {
+    if (investigationIsAssessmentTurn(turn)) indexes.push(index);
+  });
+  return indexes;
+}
+
+/** The two coverage gaps that carry no limitation of their own, named so Still open can say which. */
+export function investigationEvidenceCoverageGaps(
+  projection: Pick<InvestigationEvidenceProjection, "coverage"> & {
+    sources: readonly { id: string; tool: string; confirmedSuccess: boolean }[];
+    groups: readonly {
+      latest: {
+        relevance: "target" | "producer-related" | "broader";
+        source: { id: string };
+      };
+    }[];
+  },
+  targetKind?: string,
+): { noEvidence: boolean; noTargetDiagnosis: boolean } {
+  // Diagnose covers workloads only; a target it cannot bundle (an HPA, a
+  // Service) is read through get_resource and issues, and that is complete.
+  if (targetKind !== undefined && !isDiagnosableWorkloadKind(targetKind))
+    return {
+      noEvidence: projection.coverage.projected === 0,
+      noTargetDiagnosis: false,
+    };
+  const completeDiagnosisSourceIds = new Set(
+    projection.sources
+      .filter((source) => source.tool === "diagnose" && source.confirmedSuccess)
+      .map((source) => source.id),
+  );
+  const hasTargetDiagnosis = projection.groups.some(
+    (group) =>
+      group.latest.relevance !== "broader" &&
+      completeDiagnosisSourceIds.has(group.latest.source.id),
+  );
+  return {
+    noEvidence: projection.coverage.projected === 0,
+    noTargetDiagnosis: !hasTargetDiagnosis,
+  };
 }
 
 export function investigationEvidenceCoverageLimited(
@@ -318,21 +417,13 @@ export function investigationEvidenceCoverageLimited(
       };
     }[];
   },
+  targetKind?: string,
 ): boolean {
-  const completeDiagnosisSourceIds = new Set(
-    projection.sources
-      .filter((source) => source.tool === "diagnose" && source.confirmedSuccess)
-      .map((source) => source.id),
-  );
-  const hasTargetDiagnosis = projection.groups.some(
-    (group) =>
-      group.latest.relevance !== "broader" &&
-      completeDiagnosisSourceIds.has(group.latest.source.id),
-  );
+  const gaps = investigationEvidenceCoverageGaps(projection, targetKind);
   return (
     projection.limitations.length > 0 ||
-    projection.coverage.projected === 0 ||
-    !hasTargetDiagnosis
+    gaps.noEvidence ||
+    gaps.noTargetDiagnosis
   );
 }
 
@@ -353,11 +444,142 @@ interface HealthConflictGroup {
     tier: "key" | "supporting" | "context" | "checked";
     tone: string;
     title?: string;
+    summary?: string;
+    /** The card's payload; an events card carries the events it summarises. */
+    data?: {
+      type: string;
+      events?: readonly { reason: string; message: string; type?: string }[];
+    };
     /** Which turn captured this reading; a note cannot explain a later one. */
-    source?: { turnIndex: number };
+    source?: { turnIndex: number; id?: string };
   };
 }
 
+// Group ids that are the same observation for the reader's question. Two
+// routes: a shared display identity (a log stream read through two calls),
+// and for events, the same warning recorded at two scopes about the
+// investigated workload — its Deployment's event feed and its Pod's carry one
+// readiness failure as two cards. The event's own reason and message decide,
+// within one namespace and only among cards about this target; a name never
+// does.
+function healthTwinIds(
+  groups: readonly HealthConflictGroup[],
+): (group: HealthConflictGroup) => Set<string> {
+  const byKey = new Map<string, Set<string>>();
+  const keysOf = (group: HealthConflictGroup): string[] => {
+    const keys: string[] = [];
+    if (group.identity) keys.push(`${group.kind}\u0000${group.identity}`);
+    if (
+      group.kind === "events" &&
+      group.latest.relevance !== "broader" &&
+      group.identity &&
+      group.latest.data?.type === "events"
+    ) {
+      // The whole adverse set has to match: a Pod card with warning A is not
+      // the Deployment card that carries A and B.
+      const events = group.latest.data.events ?? [];
+      const warnings = events.filter(
+        (event) => event.type === undefined || event.type === "Warning",
+      );
+      const namespace = /^\S+\s+([^/\s]+)\//.exec(group.identity)?.[1];
+      if (warnings.length > 0 && namespace) {
+        const set = [
+          ...new Set(
+            warnings.map(
+              (event) =>
+                `${event.reason.toLowerCase()}|${event.message.toLowerCase().replace(/\s+/g, " ").trim()}`,
+            ),
+          ),
+        ]
+          .sort()
+          .join("\u0001");
+        keys.push(`events\u0000${namespace}\u0000${set}`);
+      }
+    }
+    return keys;
+  };
+  for (const group of groups) {
+    if (!group.id) continue;
+    for (const key of keysOf(group)) {
+      const ids = byKey.get(key) ?? new Set<string>();
+      ids.add(group.id);
+      byKey.set(key, ids);
+    }
+  }
+  return (group) => {
+    const ids = new Set<string>([group.id ?? ""]);
+    for (const key of keysOf(group))
+      for (const id of byKey.get(key) ?? []) ids.add(id);
+    return ids;
+  };
+}
+
+/**
+ * One adverse Radar card on a healthy verdict, with the agent's position on
+ * it: it read the card as not a live problem (explained), as related but not
+ * what matters (related), never linked a reading to it (unaddressed), or
+ * called it a cause or symptom while still reporting healthy (contradiction).
+ * The reader sees which of the four it is, in words, next to the verdict.
+ */
+export interface InvestigationHealthSignal {
+  groupId?: string;
+  sourceId?: string;
+  title: string;
+  status: "explained" | "related" | "unaddressed" | "contradiction";
+  role?: string;
+  claim?: string;
+}
+
+export function investigationHealthSignals(
+  projection: { groups: readonly HealthConflictGroup[] },
+  caseItems:
+    | readonly {
+        role: string;
+        placement: "card" | "revision" | "source";
+        claim: string;
+        groupId?: string;
+        source?: { turnIndex: number };
+      }[]
+    | undefined,
+): InvestigationHealthSignal[] {
+  const conflicting = investigationHealthConflictGroups(projection);
+  if (conflicting.length === 0) return [];
+  const twinsOf = healthTwinIds(projection.groups);
+  return conflicting.map((group) => {
+    const sameStream = twinsOf(group);
+    const fresh = (caseItems ?? []).filter(
+      (item) =>
+        item.groupId &&
+        sameStream.has(item.groupId) &&
+        item.placement === "card" &&
+        !(
+          group.latest.source !== undefined &&
+          item.source !== undefined &&
+          group.latest.source.turnIndex > item.source.turnIndex
+        ),
+    );
+    const base = {
+      groupId: group.id,
+      sourceId: group.latest.source?.id,
+      title: group.latest.title ?? group.kind,
+    };
+    const asserting = fresh.find(
+      (item) => item.role === "cause" || item.role === "symptom",
+    );
+    if (asserting)
+      return { ...base, status: "contradiction", role: asserting.role };
+    const benign = fresh.find(
+      (item) => item.role === "benign" && item.claim.trim() !== "",
+    );
+    if (benign) return { ...base, status: "explained", claim: benign.claim };
+    const demoted = fresh.find(
+      (item) => item.role === "demoted" && item.claim.trim() !== "",
+    );
+    if (demoted) return { ...base, status: "related", claim: demoted.claim };
+    return { ...base, status: "unaddressed" };
+  });
+}
+
 export function investigationHealthConflictGroups<
   G extends HealthConflictGroup,
 >(projection: { groups: readonly G[] }): G[] {
@@ -410,19 +632,10 @@ export function investigationHealthConflictExplainedBy(
   // agent addressed the stream: it explained one card, and the conflict is
   // recorded on its twin. Group ids that share an identity are the same
   // underlying observation for this question.
-  const twins = new Map<string, Set<string>>();
-  for (const group of projection.groups) {
-    if (!group.id || !group.identity) continue;
-    const key = `${group.kind}\u0000${group.identity}`;
-    const ids = twins.get(key) ?? new Set<string>();
-    ids.add(group.id);
-    twins.set(key, ids);
-  }
+  const twinsOf = healthTwinIds(projection.groups);
   const titles: string[] = [];
   for (const group of conflicting) {
-    const sameStream =
-      (group.identity && twins.get(`${group.kind}\u0000${group.identity}`)) ||
-      new Set<string>([group.id ?? ""]);
+    const sameStream = twinsOf(group);
     const onGroup = caseItems.filter(
       (item) => item.groupId && sameStream.has(item.groupId),
     );

package/src/components/diagnose/investigationStory.test.ts

@@ -0,0 +1,161 @@
+import { describe, expect, it } from "vitest";
+import {
+  splitStory,
+  storyHasPlacements,
+  storyPlainText,
+  storyReferenceHref,
+  storyReferenceIndex,
+  UNRESOLVED_STORY_INDEX,
+} from "./investigationStory";
+
+describe("splitStory", () => {
+  it("places a marker on its own line and references one inside a sentence", () => {
+    const { segments } = splitStory(
+      "The pod crashes.\n\n[[radar:evidence=0]]\n\nAs [[radar:evidence=0]] shows, auth fails.\n  [[radar:evidence=2]]  \nDone.",
+    );
+    expect(segments).toEqual([
+      { kind: "prose", markdown: "The pod crashes." },
+      { kind: "placement", index: 0 },
+      {
+        kind: "prose",
+        markdown:
+          "As [[[radar:evidence=0]]](#radar-evidence-0) shows, auth fails.",
+      },
+      { kind: "placement", index: 2 },
+      { kind: "prose", markdown: "Done." },
+    ]);
+    expect(JSON.stringify(segments)).toContain("#radar-evidence-0)");
+  });
+
+  it("treats markers inside fences, inline code and blockquotes as literal text", () => {
+    const report = [
+      "Quoted output:",
+      "```",
+      "[[radar:evidence=1]]",
+      "```",
+      "Inline `[[radar:evidence=1]]` is code, but [[radar:evidence=3]] is not.",
+      "> [[radar:evidence=4]]",
+      "~~~txt",
+      "[[radar:evidence=5]]",
+      "~~~",
+    ].join("\n");
+    const { segments } = splitStory(report);
+    expect(segments.filter((s) => s.kind === "placement")).toEqual([]);
+    expect(JSON.stringify(segments)).toContain("#radar-evidence-3)");
+    const prose = segments
+      .map((s) => (s.kind === "prose" ? s.markdown : ""))
+      .join("\n");
+    expect(prose).toContain("`[[radar:evidence=1]]`");
+    expect(prose).toContain("> [[radar:evidence=4]]");
+    expect(prose).toContain("[[[radar:evidence=3]]](#radar-evidence-3)");
+  });
+
+  it("keeps indented-code markers and unbalanced closing fences literal", () => {
+    const indented = splitStory("Text.\n\n    [[radar:evidence=0]]");
+    expect(indented.segments.every((s) => s.kind === "prose")).toBe(true);
+    expect(JSON.stringify(indented.segments)).not.toContain("#radar-evidence");
+    expect(
+      indented.segments.map((s) => s.kind === "prose" && s.markdown).join("\n"),
+    ).toContain("    [[radar:evidence=0]]");
+    const fence = splitStory(
+      "```\n````not-a-close\n[[radar:evidence=0]]\n```\n\n[[radar:evidence=1]]",
+    );
+    expect(
+      fence.segments
+        .filter((s) => s.kind === "placement")
+        .map((s) => s.kind === "placement" && s.index),
+    ).toEqual([1]);
+  });
+
+  it("resolves a ref-form marker to its item, and flags one nothing cites", () => {
+    const ref = "ev_" + "a".repeat(26) + "_" + "b".repeat(26);
+    const stray = "ev_" + "c".repeat(26) + "_" + "d".repeat(26);
+    const resolve = (candidate: string) => (candidate === ref ? 2 : undefined);
+    const { segments } = splitStory(
+      `The log shows it:\n\n[[radar:evidence-ref=${ref}]]\n\nSee [[radar:evidence-ref=${ref}|compact]] and [[radar:evidence-ref=${stray}]].`,
+      resolve,
+    );
+    expect(segments[1]).toEqual({ kind: "placement", index: 2 });
+    expect(JSON.stringify(segments)).toContain("#radar-evidence-2)");
+    expect(JSON.stringify(segments)).toContain("#radar-evidence--1)");
+    expect(segments[2]).toMatchObject({ kind: "prose" });
+    const inline = (segments[2] as { markdown: string }).markdown;
+    expect(inline).toContain("](#radar-evidence-2)");
+    expect(inline).toContain(`](#radar-evidence-${UNRESOLVED_STORY_INDEX})`);
+    expect(storyPlainText(`x [[radar:evidence-ref=${ref}]] y`)).toBe("x  y");
+  });
+  it("keeps a marker inside a double-backtick code span literal", () => {
+    const { segments } = splitStory(
+      "Write `` [[radar:evidence=0]] `` to place, then see [[radar:evidence=0]].",
+    );
+    expect(JSON.stringify(segments)).toContain("#radar-evidence-0)");
+    expect((segments[0] as { markdown: string }).markdown).toContain(
+      "`` [[radar:evidence=0]] ``",
+    );
+  });
+
+  it("keeps a marker literal inside a code span that runs across lines", () => {
+    const split = splitStory(
+      "Quoted `example\n[[radar:evidence=0]]\nend` here.\n\n[[radar:evidence=0]]",
+    );
+    expect(split.segments.map((segment) => segment.kind)).toEqual([
+      "prose",
+      "placement",
+    ]);
+    expect(JSON.stringify(split.segments)).not.toContain("#radar-evidence");
+    expect((split.segments[0] as { markdown: string }).markdown).toContain(
+      "[[radar:evidence=0]]\nend`",
+    );
+  });
+
+  it("closes an open span at a fence, at a whitespace-only line, and keeps tab-indented lines literal", () => {
+    const kinds = (report: string) =>
+      splitStory(report).segments.map((segment) => segment.kind);
+    expect(kinds("Quoted `example\n~~~\nx\n~~~\n[[radar:evidence=0]]")).toEqual(
+      ["prose", "placement"],
+    );
+    expect(kinds("Quoted `example\n    \n[[radar:evidence=0]]")).toEqual([
+      "prose",
+      "placement",
+    ]);
+    // A tab-indented fence is indented code, so the marker between two of
+    // them stands on its own line in prose.
+    expect(kinds("\t~~~\n[[radar:evidence=0]]\n\t~~~")).toEqual([
+      "prose",
+      "placement",
+      "prose",
+    ]);
+    expect(kinds("\t[[radar:evidence=0]]")).toEqual(["prose"]);
+    expect(
+      JSON.stringify(splitStory("\t[[radar:evidence=0]]").segments),
+    ).not.toContain("#radar-evidence");
+  });
+
+  it("reads the compact variant as a placement flag", () => {
+    const { segments } = splitStory(
+      "A.\n[[radar:evidence=2|compact]]\nB [[radar:evidence=2|compact]].",
+    );
+    expect(segments[1]).toEqual({ kind: "placement", index: 2, compact: true });
+    expect(segments[2]).toEqual({
+      kind: "prose",
+      markdown: "B [[[radar:evidence=2|compact]]](#radar-evidence-2).",
+    });
+  });
+
+  it("keeps an unterminated fence literal to the end", () => {
+    const { segments } = splitStory("```\n[[radar:evidence=0]]\nstill code");
+    expect(segments).toEqual([
+      { kind: "prose", markdown: "```\n[[radar:evidence=0]]\nstill code" },
+    ]);
+  });
+
+  it("round-trips reference hrefs and strips markers for plain text", () => {
+    expect(storyReferenceIndex(storyReferenceHref(7))).toBe(7);
+    expect(storyReferenceIndex("#other")).toBeUndefined();
+    expect(
+      storyPlainText("A.\n\n[[radar:evidence=0]]\n\nB [[radar:evidence=1]]."),
+    ).toBe("A.\n\nB .");
+    expect(storyHasPlacements("no markers")).toBe(false);
+    expect(storyHasPlacements("x [[radar:evidence=0]]")).toBe(true);
+  });
+});