@skyhook-io/radar-app 1.14.3 → 1.14.5

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

@@ -34,6 +34,53 @@ import { groupEvidenceCoverage } from "./investigationEvidencePresentation";
 import { metricsChangeMarkers } from "./investigationMetrics";
 
 const onViewSource = vi.fn();
+
+describe("coverage already summarized by the assessment", () => {
+  it("removes only the repeated collapsed preview, retaining source details and new gaps", () => {
+    const projection = project(
+      tool(
+        "logs-denied",
+        "get_pod_logs",
+        { error: "pods/log is forbidden" },
+        { isError: true },
+      ),
+      tool("issues-cut", "issues", {}, { truncated: true }),
+    );
+    const groups = groupEvidenceCoverage(projection.limitations);
+    const line = `${groups[0].label}: ${groups[0].summary}`;
+    const renderStory = (summarizedLimits: string[], summary = "Assessment") =>
+      renderToStaticMarkup(
+        <InvestigationEvidencePane
+          projection={projection}
+          story={{ summary, report: "Analysis [[radar:evidence=0]]" }}
+          summarizedLimits={summarizedLimits}
+          collecting={false}
+          animateGroupIds={new Set()}
+          onViewSource={onViewSource}
+          onViewActivity={() => {}}
+        />,
+      );
+    const preview = (html: string) =>
+      html.match(
+        /<button[^>]*aria-controls="investigation-evidence-coverage"[\s\S]*?<\/button>/,
+      )?.[0] ?? "";
+    const firstSummary = renderToStaticMarkup(<>{groups[0].summary}</>);
+    expect(preview(renderStory([]))).toContain(firstSummary);
+    const html = renderStory([line]);
+    expect(preview(html)).not.toContain(firstSummary);
+    expect(preview(html)).toContain(groups[1].summary);
+    expect(html).toContain('aria-label="View result for Container logs"');
+    expect(html).toContain("Evidence coverage update:");
+    const allSummarized = renderStory(
+      groups.map((g) => `${g.label}: ${g.summary}`),
+    );
+    expect(preview(allSummarized)).not.toContain("line-clamp-2");
+    expect(preview(allSummarized)).toContain("Evidence coverage is incomplete");
+    for (const summary of ["", "   "]) {
+      expect(preview(renderStory([line], summary))).toContain(firstSummary);
+    }
+  });
+});
 const target = {
   kind: "Deployment",
   group: "apps",

package/src/components/diagnose/InvestigationEvidencePane.tsx

@@ -71,6 +71,7 @@ export function InvestigationEvidencePane({
   afterEvidence,
   recordNotes,
   storyShell = false,
+  summarizedLimits = [],
   revealRequest,
   onRevealReady,
 }: {
@@ -85,7 +86,11 @@ export function InvestigationEvidencePane({
    * `evidence` array. Absent on backends and runs without the story contract,
    * which keep the previous layout.
    */
-  story?: { report: string; evidence?: DiagnosisEvidenceItem[] };
+  story?: {
+    summary?: string;
+    report: string;
+    evidence?: DiagnosisEvidenceItem[];
+  };
   /** Open the story fully instead of the bounded preview — when the layout has room for it. */
   collecting: boolean;
   animateGroupIds: ReadonlySet<string>;
@@ -105,6 +110,8 @@ export function InvestigationEvidencePane({
   recordNotes?: ReactNode;
   /** No verdict yet, but the story shape is coming: keep its cards in place. */
   storyShell?: boolean;
+  /** Coverage lines already visible in the current assessment's Still open list. */
+  summarizedLimits?: readonly string[];
   /** Explicit Activity → Findings navigation, including repeat clicks. */
   revealRequest?: { sourceId: string; requestId: number };
   onRevealReady?: (sourceId: string) => void;
@@ -279,6 +286,12 @@ export function InvestigationEvidencePane({
   const limitationSummary = coverageGroups
     .map((group) => `${group.label}: ${group.summary}`)
     .join(" · ");
+  const additionalLimitations = coverageGroups
+    .map((group) => `${group.label}: ${group.summary}`)
+    .filter(
+      (line) => !story?.summary?.trim() || !summarizedLimits.includes(line),
+    )
+    .join(" · ");
   // Resolves a story placement to the agent item it names, or says why it
   // cannot: an index Radar does not know, an item the server could not bind,
   // or a bound item that matches no single observation. Only the last two
@@ -657,7 +670,7 @@ export function InvestigationEvidencePane({
                 <CoverageStrip
                   groups={coverageGroups}
                   visibleGroupIds={new Set(partition.collectionByGroup.keys())}
-                  summary={limitationSummary}
+                  summary={additionalLimitations}
                   onViewSource={onViewSource}
                   open={coverageOpen}
                   onOpenChange={setCoverageOpen}

package/src/components/diagnose/InvestigationEvidenceSections.tsx

@@ -318,7 +318,7 @@ export function CoverageStrip({
               ? "Change history is limited"
               : "Evidence coverage is incomplete"}
           </span>
-          {!historyOnly && !open ? (
+          {!historyOnly && !open && summary ? (
             <span className="line-clamp-2 text-xs text-theme-text-tertiary [overflow-wrap:anywhere]">
               {summary}
             </span>

package/src/components/diagnose/InvestigationView.tsx

@@ -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;
@@ -787,7 +788,8 @@ export function InvestigationView({
     assessment: Turn,
   ): AssessmentExplanation | undefined => {
     const sequence = assessment.resultSequence;
-    if (!sequence || !assessment.diagnosis?.rootCause) return undefined;
+    if (!sequence || !investigationIsAssessmentTurn(assessment))
+      return undefined;
     const saved = investigationExplanation(turns, sequence);
     if ((readOnly || !explanationEnabled) && saved.status === "idle")
       return undefined;
@@ -1299,13 +1301,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 +1317,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 +1350,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);
@@ -1660,7 +1664,7 @@ export function InvestigationView({
               lastApplyAttemptIdx,
               localApplyAttemptAssessmentIdx,
               interactionsBlocked,
-              hosted,
+              canApply,
               hasNewerEvidence: hasEvidenceCollectedAfterAssessment,
             })
               ? requestApply
@@ -1966,7 +1970,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}
@@ -1977,6 +1982,7 @@ export function InvestigationView({
                                 evidenceMalformed={
                                   turn.diagnosis.evidenceMalformed
                                 }
+                                omittedEntries={turn.diagnosis.omittedEntries}
                                 readOnly
                                 onViewSource={viewActivitySource}
                               />
@@ -2356,12 +2362,14 @@ export function InvestigationView({
                     story={
                       storyShape && currentAssessment?.diagnosis
                         ? {
+                            summary: currentAssessment.diagnosis.summary,
                             report: currentAssessment.diagnosis.report,
                             evidence: currentAssessment.diagnosis.evidence,
                           }
                         : undefined
                     }
                     storyShell={storyShell}
+                    summarizedLimits={storyShape ? assessmentLimits : undefined}
                     collecting={
                       explanationRequest?.status !== "running" &&
                       (requestPending ||

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

@@ -21,6 +21,7 @@ import {
 } from "./investigationCase";
 import { AssessmentSources, ResultCard, assessmentSourceRows } from "./parts";
 import { namedInventoryRows } from "./investigationEvidence/bodies/inventory";
+import { LogsBody } from "./investigationEvidence/bodies/streams";
 import type { Diagnosis, DiagnosisEvidenceItem } from "../../api/diagnose";
 
 const onViewSource = vi.fn();
@@ -1072,6 +1073,33 @@ describe("agent case placement (D-1, D-1b)", () => {
     ]);
   });
 
+  it.each(["issue", "issues"])(
+    "pins a %s citation to the issue observation",
+    (observation) => {
+      const resolved = resolveInvestigationCase(
+        projection,
+        {
+          evidence: [
+            linked(ref, "symptom", "The issue is the symptom.", {
+              kind: "Deployment",
+              group: "apps",
+              namespace: "shop",
+              name: "api",
+              observation,
+            }),
+          ],
+        },
+        0,
+      );
+      expect(resolved.items[0].placement).toBe("card");
+      expect(
+        projection.groups.find(
+          (group) => group.id === resolved.items[0].groupId,
+        )?.kind,
+      ).toBe("issue");
+    },
+  );
+
   it("pins a subject-bearing item to exactly the observation it names", () => {
     const resolved = resolveInvestigationCase(
       projection,
@@ -1187,6 +1215,61 @@ describe("agent case placement (D-1, D-1b)", () => {
     ]);
   });
 
+  it.each([
+    ["resolved", "app", "app", "card"],
+    ["wrong container", "proxy", "app", "source"],
+    ["unknown container", undefined, "app", "source"],
+  ] as const)(
+    "places a named log claim only against its %s stream",
+    (_name, container, claimedContainer, placement) => {
+      const ref = evidenceRef("a", "b");
+      const projection = project(
+        tool(
+          "logs",
+          "get_pod_logs",
+          {
+            container,
+            lines: ["ERROR missing configuration"],
+            totalLines: 1,
+            matchedLines: 1,
+            fallback: false,
+          },
+          {
+            summary: JSON.stringify({ namespace: "shop", name: "api-abc" }),
+            evidenceRef: ref,
+          },
+        ),
+      );
+      const resolved = resolveInvestigationCase(
+        projection,
+        {
+          evidence: [
+            linked(ref, "cause", "The application is missing configuration.", {
+              kind: "Pod",
+              namespace: "shop",
+              name: "api-abc",
+              container: claimedContainer,
+              observation: "logs",
+            }),
+          ],
+        },
+        0,
+      );
+      expect(resolved.items[0].placement).toBe(placement);
+      if (placement === "card") {
+        expect(resolved.items[0].groupId).toBe(projection.groups[0].id);
+      }
+      if (container === undefined) {
+        const data = projection.groups[0].latest.data;
+        expect(data.type).toBe("logs");
+        if (data.type !== "logs") throw new Error("expected log evidence");
+        const html = renderToStaticMarkup(<LogsBody data={data} />);
+        expect(html).toContain("container unknown");
+        expect(html).not.toContain("default container");
+      }
+    },
+  );
+
   it("binds to the exact earlier read and renders on its revision row, not the card head", () => {
     const first = evidenceRef("a", "c");
     const second = evidenceRef("a", "d");

package/src/components/diagnose/investigationCase.ts

@@ -54,7 +54,7 @@ export interface InvestigationCaseResolution {
 }
 
 /**
- * One half of a Go↔TS contract: `evidenceRoles` in internal/ai/parse.go and the
+ * One half of a Go↔TS contract: `Roles` in pkg/investigation/verdict.go and the
  * DiagnosisEvidenceRole union in api/diagnose.ts must list exactly these roles.
  * A role the parser accepts but this set omits is bound server-side and then
  * silently dropped here. Change all three together.
@@ -388,7 +388,8 @@ function observationMatchesSubject(
     // "metrics" alone cannot name one; "metrics:<category>" picks the chart
     // whose identity ends in that category. An agent-run query is one chart,
     // so a qualifier on it carries no meaning.
-    const [kind, qualifier] = subject.observation.toLowerCase().split(":", 2);
+    const [word, qualifier] = subject.observation.toLowerCase().split(":", 2);
+    const kind = word === "issues" ? "issue" : word;
     if (
       kind !== observation.data.type &&
       !(kind === "resource" && RESOURCE_SHAPED.has(observation.data.type))

package/src/components/diagnose/investigationEvidence/adapters/coverage.test.tsx

@@ -434,6 +434,28 @@ describe("posture scans that did not finish", () => {
 });
 
 describe("listing cards (helm releases, packages, search)", () => {
+  it.each([null, []])("accepts an empty Helm result: %j", (payload) => {
+    const projection = project([
+      tool("helm", "list_helm_releases", payload, {
+        summary: JSON.stringify({ namespace: "shop" }),
+      }),
+    ]);
+    expect(projection.groups).toHaveLength(0);
+    expect(projection.limitations).toEqual([
+      expect.objectContaining({
+        source: "Resource inventory",
+        kind: "unknown",
+      }),
+    ]);
+  });
+
+  it.each([{}, "", 0])("rejects malformed Helm results: %j", (payload) => {
+    const projection = project([tool("helm", "list_helm_releases", payload)]);
+    expect(projection.limitations).toEqual([
+      expect.objectContaining({ source: "Helm releases", kind: "unknown" }),
+    ]);
+  });
+
   it("lists Helm releases with their status and chart", () => {
     const projection = project([
       tool(

package/src/components/diagnose/investigationEvidence/adapters/diagnose.test.ts

@@ -264,7 +264,7 @@ describe("diagnose metrics evidence", () => {
     expect(groups.map((group) => group.latest.title)).toEqual([
       "CPU usage · Deployment shop/api",
       "Memory working set · Deployment shop/api",
-      "Restarts · Deployment shop/api",
+      "Restarts in trailing 1h · Deployment shop/api",
     ]);
     for (const group of groups) {
       expect(group.latest.relevance).toBe("target");
@@ -289,6 +289,12 @@ describe("diagnose metrics evidence", () => {
       expect(investigationEvidenceSubjectRef(data)).toEqual(data.subject);
     }
     const [cpu, , restarts] = groups;
+    expect(restarts.latest.title).toContain("Restarts in trailing 1h");
+    expect(restarts.latest.data).toMatchObject({
+      type: "metrics",
+      label: "Restarts in trailing 1h",
+      unit: "count",
+    });
     expect(cpu.latest.summary).toBe("2 current pods · 60m window · 1m2s step");
     const cpuData = cpu.latest.data;
     if (cpuData.type !== "metrics") throw new Error("expected metrics");
@@ -562,7 +568,7 @@ describe("diagnose metrics evidence", () => {
     ]);
     const groups = groupsOf(projection.groups, "metrics");
     expect(groups.map((group) => group.latest.title)).toEqual([
-      "Restarts · Deployment shop/api",
+      "Restarts in trailing 1h · Deployment shop/api",
     ]);
     expect(
       projection.limitations.some(

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

@@ -821,7 +821,7 @@ export function adaptDiagnose(
 const DIAGNOSE_METRICS_LABELS: Record<string, string> = {
   cpu: "CPU usage",
   memory: "Memory working set",
-  restarts: "Restarts",
+  restarts: "Restarts in trailing 1h",
 };
 /**
  * The vitals `diagnose` captured inside the same call: one chart per category

package/src/components/diagnose/investigationEvidence/adapters/listings.ts

@@ -13,6 +13,8 @@ export function adaptListHelmReleases(
   source: InvestigationEvidenceSource,
   payload: unknown,
 ): void {
+  // Retained runs may contain the Helm producer's nil-slice encoding.
+  if (payload === null) payload = [];
   if (!Array.isArray(payload)) {
     invalidPayload(builder, source);
     return;

package/src/components/diagnose/investigationEvidence/adapters/logs.test.ts

@@ -13,6 +13,66 @@ import {
   workloadLogsPayload,
 } from "../evidenceFixtures";
 
+describe("pod logs container identity", () => {
+  const payload = {
+    lines: ["ERROR missing configuration"],
+    totalLines: 1,
+    matchedLines: 1,
+    fallback: false,
+  };
+
+  it.each([
+    ["resolved identity", { ...payload, container: "app" }, {}, "app"],
+    [
+      "producer identity wins",
+      { ...payload, container: "app" },
+      { container: "proxy" },
+      "app",
+    ],
+    ["saved explicit request", payload, { container: "app" }, "app"],
+    ["saved unspecified request", payload, {}, undefined],
+  ])("uses %s", (_name, result, args, expected) => {
+    const projection = project([
+      tool("logs", "get_pod_logs", result, {
+        summary: JSON.stringify({ namespace: "shop", name: "api", ...args }),
+      }),
+    ]);
+    const observation = groupsOf(projection.groups, "logs")[0].latest;
+    expect(observation.data).toMatchObject({
+      type: "logs",
+      container: expected,
+    });
+    expect(observation.title).toContain(expected ?? "container unknown");
+  });
+
+  it("does not merge separate unknown streams or current and previous instances", () => {
+    const projection = project([
+      tool("unknown-1", "get_pod_logs", payload),
+      tool("unknown-2", "get_pod_logs", payload),
+      tool("current", "get_pod_logs", { ...payload, container: "app" }),
+      tool(
+        "previous",
+        "get_pod_logs",
+        { ...payload, container: "app" },
+        {
+          summary: JSON.stringify({
+            namespace: "shop",
+            name: "api",
+            previous: true,
+          }),
+        },
+      ),
+    ]);
+    const groups = groupsOf(projection.groups, "logs");
+    expect(groups).toHaveLength(4);
+    expect(new Set(groups.map((group) => group.identity)).size).toBe(4);
+    expect(groups.slice(2).map((group) => group.identity)).toEqual([
+      "logs:current:api:app",
+      "logs:previous:api:app",
+    ]);
+  });
+});
+
 // The get_workload_logs response shape, with the stream rows fetchPodLogs
 // emits per pod and container.
 

package/src/components/diagnose/investigationEvidence/adapters/logs.ts

@@ -39,9 +39,13 @@ export function adaptPodLogs(
   const warnings = stringArray(value?.warnings) ?? [];
   const args = record(source.args ? parseJSON(source.args) : undefined);
   const pod = nonEmptyString(args?.name) ? args.name : "Pod";
-  const container = nonEmptyString(args?.container)
-    ? args.container
-    : "default container";
+  // Saved results may omit container identity while their arguments explicitly
+  // name the requested container. Otherwise its identity is unknown.
+  const container = nonEmptyString(value?.container)
+    ? value.container
+    : nonEmptyString(args?.container)
+      ? args.container
+      : undefined;
   addLogs(
     builder,
     source,

package/src/components/diagnose/investigationEvidence/bodies/streams.tsx

@@ -33,7 +33,7 @@ export function LogsBody({
         {condensed ? null : (
           <>
             <Badge tone="structural" size="sm">
-              {data.pod} / {data.container}
+              {data.pod} / {data.container ?? "container unknown"}
             </Badge>
             <Badge severity="neutral" size="sm">
               {data.previous ? "previous instance" : "current instance"}

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

@@ -193,6 +193,8 @@ const INVESTIGATION_RESULT_LABELS: Readonly<Record<string, string>> = {
   list_packages: "Installed packages",
   search: "Search results",
   discover_metrics: "Metric discovery",
+  get_cost: "Cost",
+  get_rightsizing: "Rightsizing",
 };
 export function investigationResultLabel(
   source: InvestigationEvidenceSource,
@@ -910,19 +912,20 @@ export function changesSubjectFromArgs(
 export function addLogs(
   builder: ProjectionBuilder,
   source: InvestigationEvidenceSource,
-  value: DiagnosisPodLogEntry,
+  value: Omit<DiagnosisPodLogEntry, "container"> & { container?: string },
   previous: boolean,
   warnings: string[] = [],
   relevance: InvestigationEvidenceRelevance = "broader",
   namespace?: string,
 ): void {
   const lines = (value.logs?.lines ?? []).map((line) => stripAnsi(line));
+  const containerLabel = value.container ?? "container unknown";
   const normalizedWarnings = warnings.map((warning) => stripAnsi(warning));
   const normalizedError = value.error ? stripAnsi(value.error) : undefined;
   if (lines.length === 0) {
     builder.limit(
       source,
-      `${value.pod} / ${value.container}`,
+      `${value.pod} / ${containerLabel}`,
       value.error ||
         "No log lines were available. This does not mean the container is healthy.",
       value.error ? "error" : "unknown",
@@ -939,7 +942,9 @@ export function addLogs(
     ),
   );
   const selectedEvidence = value.logs?.fallback !== true && diagnosticSignal;
-  const identity = `logs:${previous ? "previous" : "current"}:${value.pod}:${value.container}`;
+  // Unknown streams from separate reads need not belong to the same container.
+  const streamIdentity = value.container ?? `unknown:${source.id}`;
+  const identity = `logs:${previous ? "previous" : "current"}:${value.pod}:${streamIdentity}`;
   builder.observe(identity, "logs", source, {
     // FilterLogs' raw-tail fallback is useful provenance, but the producer did
     // not select it as diagnostic signal. Keep it in Context; only filtered
@@ -950,7 +955,7 @@ export function addLogs(
     ),
     relevance,
     tone: selectedEvidence || normalizedError ? "warning" : "neutral",
-    title: `${previous ? "Previous" : "Current"} logs · ${value.pod} / ${value.container}`,
+    title: `${previous ? "Previous" : "Current"} logs · ${value.pod} / ${containerLabel}`,
     summary:
       lines.length > 0
         ? `${lines.length} selected line${lines.length === 1 ? "" : "s"}`
@@ -969,7 +974,7 @@ export function addLogs(
   if (normalizedError) {
     builder.limit(
       source,
-      `${value.pod} / ${value.container}`,
+      `${value.pod} / ${containerLabel}`,
       normalizedError,
       "error",
     );

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

@@ -407,7 +407,7 @@ export type InvestigationEvidenceData =
   | {
       type: "logs";
       pod: string;
-      container: string;
+      container?: string;
       /** Namespace the producing call actually read; absent when unstated. */
       namespace?: string;
       previous: boolean;

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

@@ -611,14 +611,14 @@ describe("investigation action gating", () => {
       lastApplyAttemptIdx: -1,
       localApplyAttemptAssessmentIdx: -1,
       interactionsBlocked: false,
-      hosted: false,
+      canApply: true,
       hasNewerEvidence: false,
     };
     expect(canOfferInvestigationApply(base)).toBe(true);
     expect(
       canOfferInvestigationApply({ ...base, hasNewerEvidence: true }),
     ).toBe(false);
-    expect(canOfferInvestigationApply({ ...base, hosted: true })).toBe(false);
+    expect(canOfferInvestigationApply({ ...base, canApply: false })).toBe(false);
     expect(
       canOfferInvestigationApply({ ...base, interactionsBlocked: true }),
     ).toBe(false);

package/src/components/diagnose/investigationState.ts

@@ -76,7 +76,7 @@ export function canOfferInvestigationApply(input: {
   lastApplyAttemptIdx: number;
   localApplyAttemptAssessmentIdx: number;
   interactionsBlocked: boolean;
-  hosted: boolean;
+  canApply: boolean;
   hasNewerEvidence: boolean;
 }): boolean {
   return (
@@ -87,7 +87,7 @@ export function canOfferInvestigationApply(input: {
         input.localApplyAttemptAssessmentIdx,
       ) &&
     !input.interactionsBlocked &&
-    !input.hosted &&
+    input.canApply &&
     !input.hasNewerEvidence
   );
 }