@obsunified/collector 2.2.1 → 2.3.0

package/src/plugins/connected-routes/deep-link-shapes.test.ts

@@ -0,0 +1,44 @@
+import { describe, expect, it } from "vitest";
+import { hrefForEntity, linksFromAi, linksFromEvalResults } from "./manifest";
+
+describe("connected-routes manifest link shapes", () => {
+	it("routes eval, service and ai_call entities to deep-linkable hashes", () => {
+		expect(hrefForEntity("eval", "case 1")).toBe("#/evaluations/case%201");
+		expect(hrefForEntity("service", "checkout")).toBe(
+			"#/service-map?service=checkout",
+		);
+		expect(hrefForEntity("ai_call", "call-1")).toBe("#/ai/calls/call-1");
+	});
+
+	it("carries the eval id and the ai call id in section links", () => {
+		const evals = linksFromEvalResults(
+			[
+				{
+					id: "eval-1",
+					actionId: "act-1",
+					projectId: "default",
+					evaluatorName: "groundedness",
+					evaluatorVersion: "1",
+					score: 1,
+					passed: 1,
+					reasoning: null,
+					rubricJson: null,
+				},
+			],
+			"Evals",
+		);
+		expect(evals.links[0].href).toBe("#/evaluations/eval-1");
+		const ai = linksFromAi(
+			[
+				{
+					callId: "call/1",
+					provider: "openai",
+					modelName: "gpt",
+				} as unknown as Parameters<typeof linksFromAi>[0][number],
+			],
+			"AI",
+		);
+		expect(ai.links[0].href).toBe("#/ai/calls/call%2F1");
+		expect(ai.links[0].entityId).toBe("call/1");
+	});
+});

package/src/plugins/connected-routes/manifest.test.ts

@@ -0,0 +1,224 @@
+import { KNOWN_TABS, parseDashboardRouteHash } from "@obsunified/types";
+import { describe, expect, it } from "vitest";
+import {
+	hrefForEntity,
+	linksFromActions,
+	linksFromAi,
+	linksFromArtifacts,
+	linksFromEvalResults,
+	linksFromLogs,
+	linksFromMetricExemplars,
+	linksFromRetrievalEvents,
+	linksFromSpans,
+	linksFromToolCalls,
+	linksFromUsage,
+	linkToAction,
+	linkToAgentRun,
+	linkToSession,
+	linkToTrace,
+	MAX_LINKS_INLINE,
+	resolveFaultLocusTarget,
+} from "./manifest";
+
+const tabOf = (href: string) =>
+	href.replace(/^#\//, "").split(/[/?#]/)[0] ?? "";
+
+describe("connected manifest hrefs target real router tabs", () => {
+	it("tool call overflow, retrievals, evals and artifacts avoid unknown tabs", () => {
+		const many = Array.from({ length: MAX_LINKS_INLINE + 1 }, (_, i) => ({
+			id: `t${i}`,
+			actionId: "a1",
+			toolName: "search",
+		}));
+		const hrefs = [
+			linksFromToolCalls(many as never, "Tools").links[0]?.href,
+			linksFromRetrievalEvents(
+				[
+					{
+						id: "r1",
+						actionId: "a1",
+						retrieverName: "kb",
+						totalResults: 3,
+					},
+				] as never,
+				"R",
+			).links[0]?.href,
+			linksFromEvalResults(
+				[{ id: "e1", actionId: "a1", evaluatorName: "g", passed: 1 }] as never,
+				"E",
+			).links[0]?.href,
+			linksFromArtifacts(
+				[
+					{
+						id: "x1",
+						actionId: "a1",
+						artifactName: "plan",
+						artifactType: "json",
+					},
+				] as never,
+				"A",
+			).links[0]?.href,
+		];
+		expect(hrefs).toEqual([
+			"#/tool-calls",
+			"#/actions/a1",
+			"#/evaluations/e1",
+			"#/actions/a1",
+		]);
+		for (const href of hrefs) {
+			expect(KNOWN_TABS.has(tabOf(href ?? ""))).toBe(true);
+			expect(parseDashboardRouteHash(href ?? "").ok).toBe(true);
+		}
+	});
+
+	it("emits canonical routes from all link builders and round-trips through parseDashboardRouteHash", () => {
+		expect(linkToTrace("trace-1").href).toBe("#/traces?trace=trace-1");
+		expect(linkToSession("sess/1").href).toBe("#/replay?session=sess%2F1");
+		expect(linkToAction("act/1").href).toBe("#/actions/act%2F1");
+		expect(linkToAgentRun("run/1").href).toBe("#/agent-runs/run%2F1");
+
+		const inlineSpans = linksFromSpans(
+			[
+				{
+					traceId: "tr-1",
+					spanId: "sp-1",
+					serviceName: "api",
+					spanName: "GET /",
+				} as never,
+			],
+			"Spans",
+		);
+		expect(inlineSpans.links[0]?.href).toBe("#/traces?trace=tr-1&span=sp-1");
+		expect(parseDashboardRouteHash(inlineSpans.links[0]?.href ?? "")).toEqual({
+			ok: true,
+			route: { tab: "traces", traceId: "tr-1", spanId: "sp-1" },
+		});
+
+		const manySpans = linksFromSpans(
+			Array.from({ length: MAX_LINKS_INLINE + 1 }, (_, i) => ({
+				traceId: "tr-many",
+				spanId: `sp-${i}`,
+				serviceName: "api",
+				spanName: "op",
+			})) as never,
+			"Spans",
+		);
+		expect(manySpans.links[0]?.href).toBe("#/traces?q=tr-many");
+
+		const inlineLogs = linksFromLogs(
+			[
+				{
+					logId: "log-1",
+					traceId: "tr-1",
+					severity: "ERROR",
+					message: "boom",
+				} as never,
+			],
+			"Logs",
+		);
+		expect(inlineLogs.links[0]?.href).toBe("#/logs?id=log-1");
+
+		const inlineUsage = linksFromUsage(
+			[
+				{
+					eventId: "ev-1",
+					eventType: "click",
+					eventName: "buy",
+				} as never,
+			],
+			"Usage",
+		);
+		expect(inlineUsage.links[0]?.href).toBe("#/usage?id=ev-1");
+
+		const inlineExemplars = linksFromMetricExemplars(
+			[
+				{
+					traceId: "tr-1",
+					spanId: "sp-2",
+					serviceName: "api",
+					metricName: "latency",
+					value: 42,
+					tsNs: "100",
+				} as never,
+			],
+			"Exemplars",
+		);
+		expect(inlineExemplars.links[0]?.href).toBe(
+			"#/traces?trace=tr-1&span=sp-2",
+		);
+
+		const inlineAi = linksFromAi(
+			[
+				{
+					callId: "call/1",
+					provider: "openai",
+					modelName: "gpt-4o",
+				} as never,
+			],
+			"AI",
+		);
+		expect(inlineAi.links[0]?.href).toBe("#/ai/calls/call%2F1");
+
+		const inlineActions = linksFromActions(
+			[{ id: "act-1", actionKind: "step", name: "plan" } as never],
+			"Actions",
+		);
+		expect(inlineActions.links[0]?.href).toBe("#/actions/act-1");
+	});
+
+	it("hrefForEntity only emits router tabs for every evidence kind", () => {
+		for (const kind of [
+			"trace",
+			"span",
+			"alert",
+			"analysis",
+			"service",
+			"agent_run",
+			"action",
+			"tool_call",
+			"ai_call",
+			"profile",
+			"change",
+			"finding",
+			"incident",
+			"eval",
+			"log",
+			"replay",
+			"docs",
+		]) {
+			const href = hrefForEntity(kind, "id-1");
+			expect(KNOWN_TABS.has(tabOf(href)), kind).toBe(true);
+			expect(parseDashboardRouteHash(href).ok, kind).toBe(true);
+		}
+		expect(hrefForEntity("trace", "abc")).toBe("#/traces?trace=abc");
+		expect(hrefForEntity("alert", "al 1")).toBe("#/alerts?id=al+1");
+		expect(hrefForEntity("ai_call", "c1")).toBe("#/ai/calls/c1");
+	});
+});
+
+describe("resolveFaultLocusTarget", () => {
+	const trace = "a".repeat(32);
+	const span = "b".repeat(16);
+	it("classifies service nodes, bare services and spans", () => {
+		expect(
+			resolveFaultLocusTarget("service:prod:default:checkout-api"),
+		).toEqual({
+			entityKind: "service",
+			entityId: "service:prod:default:checkout-api",
+			href: "#/service-map?service=checkout-api",
+		});
+		expect(resolveFaultLocusTarget("checkout-api")).toMatchObject({
+			entityKind: "service",
+			href: "#/service-map?service=checkout-api",
+		});
+		expect(resolveFaultLocusTarget(`${trace}:${span}`)).toEqual({
+			entityKind: "span",
+			entityId: `${trace}:${span}`,
+			href: `#/traces?trace=${trace}&span=${span}`,
+		});
+		expect(resolveFaultLocusTarget(span)).toMatchObject({
+			entityKind: "span",
+			href: `#/evidence?kind=span&id=${span}`,
+		});
+	});
+});

package/src/plugins/connected-routes/manifest.ts

@@ -1,4 +1,11 @@
-import type { CausalProofTier, RelationshipCertainty } from "@obsunified/types";
+import {
+	type CausalProofTier,
+	dashboardRouteToHref,
+	type EvidenceEntityKind,
+	type RelationshipCertainty,
+	routeForEntity,
+	hrefForEntity as sharedHrefForEntity,
+} from "@obsunified/types";
 import type {
 	ActionRef,
 	AICallRef,
@@ -15,6 +22,8 @@ import type {
 import type { CausalConfidence } from "../../lib/identity-index/types";
 import type { SqlDb } from "../../lib/sql-db";
 
+export { routeForEntity };
+
 export type ConnectedEntityKind =
 	| "span"
 	| "profile"
@@ -55,7 +64,7 @@ export interface ConnectedLink {
 	href: string;
 	count?: number;
 	sample?: string;
-	entityKind?: ConnectedEntityKind | "trace" | "eval";
+	entityKind?: ConnectedEntityKind | EvidenceEntityKind;
 	entityId?: string;
 	source?: string;
 	confidence?: number;
@@ -90,7 +99,7 @@ export const linkToTrace = (
 	label?: string,
 ): ConnectedLink => ({
 	label: label ?? `trace ${traceId.slice(0, 12)}`,
-	href: `#/traces/${traceId}`,
+	href: dashboardRouteToHref({ tab: "traces", traceId }),
 	entityKind: "trace",
 	entityId: traceId,
 });
@@ -104,7 +113,7 @@ export const linkToSession = (sessionId: string): ConnectedLink => ({
 		sessionId.length > 12
 			? `session …${sessionId.slice(-12)}`
 			: `session ${sessionId}`,
-	href: `#/replay?session=${encodeURIComponent(sessionId)}`,
+	href: dashboardRouteToHref({ tab: "replay", sessionId }),
 	sample: sessionId,
 	entityKind: "replay",
 	entityId: sessionId,
@@ -127,7 +136,10 @@ export const linksFromSpans = (
 			links: [
 				{
 					label: `${spans.length} spans`,
-					href: `#/traces?q=${encodeURIComponent(spans[0].traceId)}`,
+					href: dashboardRouteToHref({
+						tab: "traces",
+						query: spans[0].traceId,
+					}),
 					count: spans.length,
 					sample: truncate(
 						`${spans[0].serviceName ?? "?"} · ${spans[0].spanName}`,
@@ -140,7 +152,11 @@ export const linksFromSpans = (
 		label: prefix,
 		links: spans.map((s) => ({
 			label: `${s.serviceName ?? "?"} · ${truncate(s.spanName, 40)}`,
-			href: `#/traces/${s.traceId}#span=${s.spanId}`,
+			href: dashboardRouteToHref({
+				tab: "traces",
+				traceId: s.traceId,
+				spanId: s.spanId,
+			}),
 		})),
 	};
 };
@@ -163,7 +179,10 @@ export const linksFromLogs = (
 			links: [
 				{
 					label: `${logs.length} logs`,
-					href: `#/logs?q=${encodeURIComponent(sample.traceId ?? "")}`,
+					href: dashboardRouteToHref({
+						tab: "logs",
+						...(sample.traceId ? { query: sample.traceId } : {}),
+					}),
 					count: logs.length,
 					sample: truncate(sample.message),
 				},
@@ -174,7 +193,7 @@ export const linksFromLogs = (
 		label: prefix,
 		links: logs.map((l) => ({
 			label: `[${l.severity}] ${truncate(l.message, 60)}`,
-			href: `#/logs?id=${l.logId}`,
+			href: dashboardRouteToHref({ tab: "logs", logId: l.logId }),
 		})),
 	};
 };
@@ -196,7 +215,7 @@ export const linksFromUsage = (
 			links: [
 				{
 					label: `${events.length} usage events`,
-					href: `#/usage`,
+					href: dashboardRouteToHref({ tab: "usage" }),
 					count: events.length,
 					sample: truncate(`${events[0].eventType} · ${events[0].eventName}`),
 				},
@@ -207,7 +226,7 @@ export const linksFromUsage = (
 		label: prefix,
 		links: events.map((e) => ({
 			label: `${e.eventType} · ${truncate(e.eventName, 50)}`,
-			href: `#/usage?id=${e.eventId}`,
+			href: dashboardRouteToHref({ tab: "usage", usageId: e.eventId }),
 		})),
 	};
 };
@@ -231,8 +250,8 @@ export const linksFromMetricExemplars = (
 				{
 					label: `${exemplars.length} metric exemplars`,
 					href: sample.traceId
-						? `#/traces/${sample.traceId}`
-						: `#/traces?q=${encodeURIComponent(sample.metricName)}`,
+						? dashboardRouteToHref({ tab: "traces", traceId: sample.traceId })
+						: dashboardRouteToHref({ tab: "traces", query: sample.metricName }),
 					count: exemplars.length,
 					sample: truncate(
 						`${sample.serviceName ?? "?"} · ${sample.metricName}=${sample.value}`,
@@ -246,10 +265,12 @@ export const linksFromMetricExemplars = (
 		links: exemplars.map((e) => ({
 			label: `${e.serviceName ?? "?"} · ${truncate(e.metricName, 40)}=${e.value}`,
 			href: e.traceId
-				? e.spanId
-					? `#/traces/${e.traceId}#span=${e.spanId}`
-					: `#/traces/${e.traceId}`
-				: `#/traces?q=${encodeURIComponent(e.metricName)}`,
+				? dashboardRouteToHref({
+						tab: "traces",
+						traceId: e.traceId,
+						...(e.spanId ? { spanId: e.spanId } : {}),
+					})
+				: dashboardRouteToHref({ tab: "traces", query: e.metricName }),
 			sample: e.tsNs,
 		})),
 	};
@@ -309,7 +330,11 @@ export const profileLinksForTrace = async (
 			label: `${icon} ${type === "offcpu" ? "Off-CPU profiles" : `${type[0].toUpperCase()}${type.slice(1)} profiles`}`,
 			links: list.map((r) => ({
 				label: `${r.service_name ?? "?"} · ${r.duration_ms}ms`,
-				href: `#/profiles/${r.id}?trace_id=${encodeURIComponent(traceId)}`,
+				href: dashboardRouteToHref({
+					tab: "profiles",
+					profileId: r.id,
+					traceId,
+				}),
 			})),
 		});
 	}
@@ -333,7 +358,7 @@ export const linksFromAi = (
 			links: [
 				{
 					label: `${calls.length} AI calls`,
-					href: `#/ai`,
+					href: dashboardRouteToHref({ tab: "ai" }),
 					count: calls.length,
 					sample: truncate(`${calls[0].provider} · ${calls[0].modelName}`),
 				},
@@ -344,7 +369,9 @@ export const linksFromAi = (
 		label: prefix,
 		links: calls.map((c) => ({
 			label: `${c.provider} · ${c.modelName}`,
-			href: `#/ai?id=${c.callId}`,
+			href: dashboardRouteToHref({ tab: "ai", aiCallId: c.callId }),
+			entityKind: "ai_call",
+			entityId: c.callId,
 		})),
 	};
 };
@@ -354,7 +381,7 @@ export const linkToAction = (
 	label?: string,
 ): ConnectedLink => ({
 	label: label ?? `action ${actionId.slice(0, 12)}`,
-	href: `#/actions/${actionId}`,
+	href: dashboardRouteToHref({ tab: "actions", actionId }),
 	entityKind: "action",
 	entityId: actionId,
 });
@@ -364,7 +391,7 @@ export const linkToAgentRun = (
 	label?: string,
 ): ConnectedLink => ({
 	label: label ?? `agent run ${runId.slice(0, 12)}`,
-	href: `#/agent-runs/${runId}`,
+	href: dashboardRouteToHref({ tab: "agent-runs", agentRunId: runId }),
 	entityKind: "agent_run",
 	entityId: runId,
 });
@@ -407,7 +434,7 @@ export const linksFromActions = (
 			links: [
 				{
 					label: `${actions.length} actions`,
-					href: `#/actions`,
+					href: dashboardRouteToHref({ tab: "actions" }),
 					count: actions.length,
 					sample: truncate(
 						`${actions[0].actionKind} · ${actions[0].name ?? "unnamed"}`,
@@ -423,7 +450,7 @@ export const linksFromActions = (
 		label: prefix,
 		links: actions.map((a) => ({
 			label: `[${a.actionKind}] ${truncate(a.name ?? "unnamed", 40)}`,
-			href: `#/actions/${a.id}`,
+			href: dashboardRouteToHref({ tab: "actions", actionId: a.id }),
 			entityKind: "action",
 			entityId: a.id,
 			...actionContextMetadata(a, metadata),
@@ -451,7 +478,7 @@ export const linksFromToolCalls = (
 			links: [
 				{
 					label: `${calls.length} tool calls`,
-					href: `#/tools`,
+					href: dashboardRouteToHref({ tab: "tool-calls" }),
 					count: calls.length,
 					sample: truncate(calls[0].toolName),
 					entityKind: "tool_call",
@@ -465,7 +492,7 @@ export const linksFromToolCalls = (
 		label: prefix,
 		links: calls.map((t) => ({
 			label: `tool: ${t.toolName}`,
-			href: `#/tool-calls/${t.id}`,
+			href: dashboardRouteToHref({ tab: "tool-calls", toolCallId: t.id }),
 			entityKind: "tool_call",
 			entityId: t.id,
 			...metadataForAction?.(t.actionId),
@@ -488,7 +515,8 @@ export const linksFromRetrievalEvents = (
 		label: prefix,
 		links: events.map((r) => ({
 			label: `retrieve: ${r.retrieverName} (${r.totalResults} docs)`,
-			href: `#/retrieval-events/${r.id}`,
+			// No dedicated retrieval tab: the owning action's detail page lists it.
+			href: dashboardRouteToHref({ tab: "actions", actionId: r.actionId }),
 		})),
 	};
 };
@@ -511,7 +539,9 @@ export const linksFromEvalResults = (
 		label: prefix,
 		links: results.map((e) => ({
 			label: `eval: ${e.evaluatorName} (${e.passed ? "passed" : "failed"})`,
-			href: `#/evals/${e.id}`,
+			// The Evaluations tab resolves this id to an eval case, falling back
+			// to the case saved from the same action.
+			href: dashboardRouteToHref({ tab: "evaluations", evaluationId: e.id }),
 			entityKind: "eval",
 			entityId: e.id,
 			...metadataForAction?.(e.actionId),
@@ -534,7 +564,80 @@ export const linksFromArtifacts = (
 		label: prefix,
 		links: arts.map((a) => ({
 			label: `artifact: ${a.artifactName} (${a.artifactType})`,
-			href: `#/artifacts/${a.id}`,
+			// No dedicated artifact tab: the owning action's detail page lists it.
+			href: dashboardRouteToHref({ tab: "actions", actionId: a.actionId }),
 		})),
 	};
 };
+
+/**
+ * Dashboard destination for an evidence entity, delegating to the shared
+ * `@obsunified/types` route contract. Unknown kinds fall back to the
+ * evidence explorer so a link never lands on the Health tab.
+ */
+export const hrefForEntity = (
+	kind: string,
+	id: string,
+	options?: { traceId?: string; spanId?: string },
+): string => sharedHrefForEntity(kind, id, options);
+
+export interface FaultLocusTarget {
+	entityKind: "service" | "span";
+	entityId: string;
+	href: string;
+}
+
+const HEX_SPAN_PAIR = /^[0-9a-f]{32}:[0-9a-f]{16}$/i;
+const HEX_SPAN_ID = /^[0-9a-f]{16}$/i;
+const NODE_KINDS = new Set([
+	"service",
+	"endpoint",
+	"database",
+	"queue",
+	"messaging_topic",
+	"topic",
+	"cache",
+	"external",
+]);
+
+/**
+ * A finding's `faultLocusEntityId` is a canonical ontology node id
+ * (`service:<env>:<ns>:<name>`, `endpoint:<env>:<ns>:<svc>:...`), a
+ * `traceId:spanId` pair, a bare span id, or a bare service name. Resolve it to
+ * the entity kind it really is and the surface that shows that kind.
+ */
+export const resolveFaultLocusTarget = (
+	faultLocusEntityId: string,
+): FaultLocusTarget => {
+	const id = faultLocusEntityId;
+	if (HEX_SPAN_PAIR.test(id)) {
+		return {
+			entityKind: "span",
+			entityId: id,
+			href: hrefForEntity("span", id),
+		};
+	}
+	if (HEX_SPAN_ID.test(id)) {
+		return {
+			entityKind: "span",
+			entityId: id,
+			href: hrefForEntity("span", id),
+		};
+	}
+	const segments = id.split(":");
+	if (segments.length > 1 && NODE_KINDS.has(segments[0] ?? "")) {
+		// service:<env>:<ns>:<name> and endpoint:<env>:<ns>:<svc>:... both carry
+		// the owning service name at index 3.
+		const name = segments[3] || segments[segments.length - 1] || id;
+		return {
+			entityKind: "service",
+			entityId: id,
+			href: hrefForEntity("service", name),
+		};
+	}
+	return {
+		entityKind: "service",
+		entityId: id,
+		href: hrefForEntity("service", id),
+	};
+};

package/src/plugins/connected-routes-links.test.ts

@@ -0,0 +1,96 @@
+import { Hono } from "hono";
+import { describe, expect, it } from "vitest";
+import { CollectorRuntime } from "../framework/collector";
+import type { CollectorEnv } from "../framework/env";
+import { recordInvestigationFinding } from "../lib/autosre-findings";
+import { openOrDeduplicateIncident } from "../lib/autosre-remediation-gate";
+import { createMigratedSqliteDb } from "../lib/test-utils/node-sqlite-db";
+import { connectedRoutesPlugin } from "./connected-routes";
+
+type Link = { href: string; entityKind?: string; entityId?: string };
+type Manifest = { up: { links: Link[] }[]; across: { links: Link[] }[] };
+
+const SERVICE_NODE = "service:prod:default:checkout-api";
+
+const setup = () => {
+	const db = createMigratedSqliteDb();
+	const app = new Hono<{ Bindings: CollectorEnv }>();
+	connectedRoutesPlugin.register(app, new CollectorRuntime());
+	const env = { DB: db as unknown as D1Database } as CollectorEnv;
+	const get = async (path: string) =>
+		(await (await app.request(path, {}, env)).json()) as Manifest;
+	return { db, get };
+};
+
+const openIncident = async (
+	db: ReturnType<typeof setup>["db"],
+	kind: "trace" | "alert",
+	anchorId: string,
+) =>
+	(
+		await openOrDeduplicateIncident(db, "default", {
+			environment: "prod",
+			targetNodeId: SERVICE_NODE,
+			symptomAnchorKind: kind,
+			symptomAnchorId: anchorId,
+			symptomFingerprint: `fp_${kind}`,
+			symptomCategory: `fp_${kind}`,
+		})
+	).incident;
+
+describe("connected links carry the real entity kind and a matching href", () => {
+	it("incident trigger signal for a trace anchor is a trace link", async () => {
+		const { db, get } = setup();
+		const incident = await openIncident(db, "trace", "trace-123");
+		const m = await get(
+			`/internal/connected/incident/${incident.id}?environment=prod`,
+		);
+		expect(m.up[0]?.links[0]).toMatchObject({
+			entityKind: "trace",
+			entityId: "trace-123",
+			href: "#/traces?trace=trace-123",
+		});
+		db.close();
+	});
+
+	it("incident trigger signal for an alert anchor stays an alert link", async () => {
+		const { db, get } = setup();
+		const incident = await openIncident(db, "alert", "rule-9");
+		const m = await get(
+			`/internal/connected/incident/${incident.id}?environment=prod`,
+		);
+		expect(m.up[0]?.links[0]).toMatchObject({
+			entityKind: "alert",
+			entityId: "rule-9",
+			href: "#/alerts?id=rule-9",
+		});
+		db.close();
+	});
+
+	it.each([
+		[SERVICE_NODE, "service", "#/service-map?service=checkout-api"],
+		["checkout-api", "service", "#/service-map?service=checkout-api"],
+	])("finding fault locus %s links as %s", async (locus, kind, href) => {
+		const { db, get } = setup();
+		const incident = await openIncident(db, "trace", "t1");
+		const finding = await recordInvestigationFinding(db, "default", {
+			environment: "prod",
+			incidentId: incident.id,
+			title: "Regression",
+			summary: "Errors after deploy",
+			causalProofTier: "corroborated_candidate",
+			symptomEntityKind: "trace",
+			symptomEntityId: "t1",
+			faultLocusEntityKind: "service",
+			faultLocusEntityId: locus,
+			causalChain: [],
+			citedEvidenceIds: [],
+		});
+		const m = await get(
+			`/internal/connected/finding/${finding.id}?environment=prod`,
+		);
+		const link = m.across[0]?.links[0];
+		expect(link).toMatchObject({ entityKind: kind, entityId: locus, href });
+		db.close();
+	});
+});