@obsunified/collector 2.2.1 → 2.2.3

package/src/lib/projects-store.test.ts

@@ -1,6 +1,6 @@
 import { describe, expect, it } from "vitest";
 import { sha256Hex } from "./hash";
-import { ProjectsStore } from "./projects-store";
+import { displayPrefix, ProjectsStore } from "./projects-store";
 import { createMigratedSqliteDb } from "./test-utils/node-sqlite-db";
 
 describe("ProjectsStore.revokeKey", () => {
@@ -23,3 +23,40 @@ describe("ProjectsStore.revokeKey", () => {
 		db.close();
 	});
 });
+
+describe("bootstrap key display prefix", () => {
+	it("never exposes a short bootstrap key in full", async () => {
+		const db = createMigratedSqliteDb();
+		const store = new ProjectsStore(db);
+		await store.bootstrapEnvKey("short-key-12345"); // 15 chars
+		const [key] = (await store.listKeys("default")).filter(
+			(k) => k.name === "bootstrap",
+		);
+		expect(key?.keyPrefix).toBe("short");
+		expect("short-key-12345".startsWith(key?.keyPrefix ?? "")).toBe(true);
+		expect(key?.keyPrefix.length).toBeLessThan("short-key-12345".length);
+		db.close();
+	});
+
+	it("keeps 16 chars for long keys, matching minted keys", () => {
+		expect(displayPrefix("a".repeat(64))).toHaveLength(16);
+		expect(displayPrefix("abc")).toBe("a");
+		expect(displayPrefix("")).toBe("");
+	});
+
+	it("shrinks a legacy full-length prefix on the next bootstrap", async () => {
+		const db = createMigratedSqliteDb();
+		const store = new ProjectsStore(db);
+		await store.bootstrapEnvKey("legacy-key-1234");
+		await db
+			.prepare(`UPDATE ingest_keys SET key_prefix = ? WHERE name = 'bootstrap'`)
+			.bind("legacy-key-1234")
+			.run();
+		await store.bootstrapEnvKey("legacy-key-1234");
+		const [key] = (await store.listKeys("default")).filter(
+			(k) => k.name === "bootstrap",
+		);
+		expect(key?.keyPrefix).toBe("legac");
+		db.close();
+	});
+});

package/src/lib/projects-store.ts

@@ -31,6 +31,15 @@ const rowToKey = (row: IngestKeyRow): IngestKey => ({
 
 const SLUG_PATTERN = /^[a-z0-9]([a-z0-9-]{0,48}[a-z0-9])?$/;
 
+/**
+ * Display identifier for a secret: at most 16 chars (what minted keys show),
+ * but never more than a third of the secret, so a short operator-chosen
+ * INGEST_KEY can never be returned in full by `keys list`.
+ */
+export function displayPrefix(plaintext: string): string {
+	return plaintext.slice(0, Math.min(16, Math.floor(plaintext.length / 3)));
+}
+
 export class ProjectsStore {
 	constructor(private readonly db: SqlDb) {}
 
@@ -189,14 +198,24 @@ export class ProjectsStore {
 		if (!plaintext) return;
 		await this.ensureDefaultProject();
 		const keyHash = await sha256Hex(plaintext);
+		const keyPrefix = displayPrefix(plaintext);
 		const existing = await this.db
-			.prepare(`SELECT id FROM ingest_keys WHERE key_hash = ?`)
+			.prepare(`SELECT id, key_prefix FROM ingest_keys WHERE key_hash = ?`)
 			.bind(keyHash)
-			.first<{ id: string }>();
-		if (existing) return;
+			.first<{ id: string; key_prefix: string }>();
+		if (existing) {
+			// Rows written before the prefix was length-capped may hold a short
+			// bootstrap key in full; shrink them to the safe display prefix.
+			if (existing.key_prefix.length > keyPrefix.length) {
+				await this.db
+					.prepare(`UPDATE ingest_keys SET key_prefix = ? WHERE id = ?`)
+					.bind(keyPrefix, existing.id)
+					.run();
+			}
+			return;
+		}
 
 		const id = randomHex(16);
-		const keyPrefix = plaintext.slice(0, Math.min(16, plaintext.length));
 		const createdAt = new Date().toISOString();
 		await this.db
 			.prepare(

package/src/lib/sql-db-postgres.integration.test.ts

@@ -28,20 +28,22 @@ import type {
 	StoredSpan,
 	UsageEventRecord,
 } from "@obsunified/types";
-import type { MiddlewareHandler } from "hono";
+import { Hono, type MiddlewareHandler } from "hono";
 import { afterAll, beforeAll, describe, expect, it } from "vitest";
 import { deriveAnalysesForProject } from "../analyses/derive";
 import { INVESTIGATION_ANALYSES } from "../analyses/investigations";
 import { TIER0_ANALYSES } from "../analyses/tier0";
 import {
-	type CollectorRuntime,
+	CollectorRuntime,
 	createTelemetryCollectorApp,
 	type SpanProcessorPlugin,
 } from "../framework/collector";
 import type { CollectorEnv, CollectorRouteContext } from "../framework/env";
 import type { DecodedMetricPoint } from "../otlp/decode";
 import { aiSpanPayloadsProcessorPlugin } from "../plugins/ai-span-payloads-processor";
+import { connectedRoutesPlugin } from "../plugins/connected-routes";
 import { identityReceiverPlugin } from "../plugins/identity-receiver";
+import { usageQueryRoutesPlugin } from "../plugins/usage-query-routes";
 import { purgeExpiredActionGraph } from "./action-retention";
 import { ActionStore } from "./actions-store";
 import { getAICallsOverview, ingestAICallBatch } from "./ai-store/calls";
@@ -1222,4 +1224,75 @@ describe.skipIf(!databaseUrl)("PostgresAdapter against a live Postgres", () => {
 		expect(errorRate.primaryValue).toBe(0.5);
 		expect(Array.isArray(errorRate.payload.sparkline)).toBe(true);
 	});
+
+	it("serves the change connected-rail and usage sessions routes without Postgres query errors", async () => {
+		const now = isoNow();
+		const later = isoIn(60 * 60 * 1000);
+		const insertSpan = (spanId: string, startTime: string) =>
+			db
+				.prepare(
+					`INSERT INTO telemetry_spans (
+						project_id, environment, trace_id, span_id, service_name, service_version,
+						span_name, status_code, start_time, end_time, duration_ms, received_at, expires_at
+					) VALUES ('default', 'default', 'trace-pg-1', ?, 'checkout', 'v9.9.9', 'POST /pay', 2, ?, ?, 5, ?, ?)`,
+				)
+				.bind(spanId, startTime, startTime, now, later)
+				.run();
+		await insertSpan("span-pg-a", "2026-01-01T00:00:00.000Z");
+		await insertSpan("span-pg-b", "2026-01-01T00:00:01.000Z");
+		await db
+			.prepare(
+				`INSERT INTO change_events (
+					project_id, environment, id, target_node_id, kind, source, summary,
+					service_name, version, occurred_at, received_at
+				) VALUES ('default', 'default', 'chg-pg-1', 'service:checkout', 'deploy', 'explicit', 'deploy v9.9.9', 'checkout', 'v9.9.9', ?, ?)`,
+			)
+			.bind(now, now)
+			.run();
+		await new UsageStore(db).ingest([
+			usageEvent({
+				eventId: "pg-s1-a",
+				sessionId: "pg-sess-1",
+				pagePath: "/a",
+			}),
+			usageEvent({
+				eventId: "pg-s1-b",
+				sessionId: "pg-sess-1",
+				pagePath: "/b",
+				eventType: "interaction",
+			}),
+		]);
+
+		const app = new Hono<{ Bindings: CollectorEnv }>();
+		const runtime = new CollectorRuntime();
+		connectedRoutesPlugin.register(app, runtime);
+		usageQueryRoutesPlugin.register(app, runtime);
+		const env = { DB: db as unknown as D1Database } as CollectorEnv;
+
+		const change = await app.request(
+			"/internal/connected/change/chg-pg-1",
+			{},
+			env,
+		);
+		expect(change.status).toBe(200);
+		const manifest = (await change.json()) as {
+			across: Array<{ links: Array<{ entityId: string }> }>;
+		};
+		const spanIds = manifest.across.flatMap((s) =>
+			s.links.map((l) => l.entityId),
+		);
+		// Most recent first, one link per span.
+		expect(spanIds).toEqual(["trace-pg-1:span-pg-b", "trace-pg-1:span-pg-a"]);
+
+		const sessions = await app.request(
+			"/internal/usage/sessions?hours=24",
+			{},
+			env,
+		);
+		expect(sessions.status).toBe(200);
+		const body = (await sessions.json()) as {
+			sessions: Array<{ sessionId: string; lastPath: string | null }>;
+		};
+		expect(body.sessions.map((r) => r.sessionId)).toContain("pg-sess-1");
+	});
 });

package/src/lib/usage-store.ts

@@ -503,15 +503,21 @@ export class UsageStore {
 					SUM(CASE WHEN event_type = 'interaction' THEN 1 ELSE 0 END) AS interaction_count,
 					SUM(CASE WHEN event_type = 'frontend_error' OR severity = 'error' THEN 1 ELSE 0 END) AS error_count,
 					MAX(CASE WHEN event_type = 'page_view' THEN CAST(COALESCE(${loadMsExpr}, ${loadTimeMsExpr}, ${durationMsExpr}) AS REAL) ELSE NULL END) AS max_load_ms,
-					(SELECT referrer FROM usage_events ref WHERE ref.project_id = ue.project_id AND ref.session_id = ue.session_id ORDER BY occurred_at ASC LIMIT 1) AS referrer,
-					(SELECT page_path FROM usage_events lp WHERE lp.project_id = ue.project_id AND lp.session_id = ue.session_id ORDER BY occurred_at DESC LIMIT 1) AS last_path
+					(SELECT referrer FROM usage_events ref WHERE ref.project_id = ? AND ref.session_id = ue.session_id ORDER BY occurred_at ASC LIMIT 1) AS referrer,
+					(SELECT page_path FROM usage_events lp WHERE lp.project_id = ? AND lp.session_id = ue.session_id ORDER BY occurred_at DESC LIMIT 1) AS last_path
 				FROM usage_events ue
 				WHERE project_id = ? AND received_at >= ?
 				GROUP BY session_id
 				ORDER BY last_seen DESC
 				LIMIT ?`,
 			)
-			.bind(options.projectId, cutoff, limit * 3)
+			.bind(
+				options.projectId,
+				options.projectId,
+				options.projectId,
+				cutoff,
+				limit * 3,
+			)
 			.all<{
 				session_id: string;
 				visitor_id: string;

package/src/migrations/052_remediation_callback.sql

@@ -0,0 +1,10 @@
+-- Persisted grant-handoff callback (RFC 0013 § 6.B, journey review J17).
+--
+-- A proposal parked for human approval may carry a webhook that receives the
+-- one-time grant token when the approval happens later. `callback_url` is the
+-- target (SSRF-guarded again at delivery time); `callback_secret` is the HMAC
+-- signing secret, stored as supplied (the collector has no at-rest encryption
+-- helper) and never returned by any GET. Both are cleared once the grant is
+-- delivered, rejected or expired.
+ALTER TABLE remediation_proposals ADD COLUMN callback_url TEXT;
+ALTER TABLE remediation_proposals ADD COLUMN callback_secret TEXT;

package/src/migrations/053_remediation_callback_delivery.sql

@@ -0,0 +1,7 @@
+-- Last grant-handoff webhook delivery outcome (RFC 0013 § 6.B).
+--
+-- JSON `{status: 'delivered'|'failed', attempts, lastError, at}` recorded after
+-- the grant webhook is attempted (up to 3 attempts). It never contains the
+-- callback URL or secret, so unlike callback_url it is kept after approval so
+-- the dashboard can flag a failed handoff.
+ALTER TABLE remediation_proposals ADD COLUMN callback_delivery TEXT;

package/src/migrations-postgres/052_remediation_callback.sql

@@ -0,0 +1,10 @@
+-- (PostgreSQL mirror) Persisted grant-handoff callback (RFC 0013 § 6.B, journey review J17).
+--
+-- A proposal parked for human approval may carry a webhook that receives the
+-- one-time grant token when the approval happens later. `callback_url` is the
+-- target (SSRF-guarded again at delivery time); `callback_secret` is the HMAC
+-- signing secret, stored as supplied (the collector has no at-rest encryption
+-- helper) and never returned by any GET. Both are cleared once the grant is
+-- delivered, rejected or expired.
+ALTER TABLE remediation_proposals ADD COLUMN IF NOT EXISTS callback_url TEXT;
+ALTER TABLE remediation_proposals ADD COLUMN IF NOT EXISTS callback_secret TEXT;

package/src/migrations-postgres/053_remediation_callback_delivery.sql

@@ -0,0 +1,7 @@
+-- (PostgreSQL mirror) Last grant-handoff webhook delivery outcome (RFC 0013 § 6.B).
+--
+-- JSON `{status: 'delivered'|'failed', attempts, lastError, at}` recorded after
+-- the grant webhook is attempted (up to 3 attempts). It never contains the
+-- callback URL or secret, so unlike callback_url it is kept after approval so
+-- the dashboard can flag a failed handoff.
+ALTER TABLE remediation_proposals ADD COLUMN IF NOT EXISTS callback_delivery TEXT;

package/src/plugins/ai-call-by-id.test.ts

@@ -0,0 +1,73 @@
+import type { MiddlewareHandler } from "hono";
+import { describe, expect, it } from "vitest";
+import { createTelemetryCollectorApp } from "../framework/collector";
+import type { CollectorEnv } from "../framework/env";
+import { MemSqlDb } from "../lib/test-utils/mem-sql-db";
+import { aiReceiverPlugin } from "./ai-receiver";
+
+const passthrough: MiddlewareHandler<{
+	Bindings: CollectorEnv;
+	Variables: { projectId: string };
+}> = async (c, next) => {
+	c.set("projectId", "default");
+	await next();
+};
+
+const app = createTelemetryCollectorApp({
+	plugins: [aiReceiverPlugin],
+	auth: { middleware: passthrough },
+	dashboardAuth: { middleware: passthrough, registerRoutes: () => {} },
+});
+
+const row = {
+	project_id: "default",
+	call_id: "call-1",
+	trace_id: "trace-1",
+	span_id: "span-1",
+	service_name: "svc",
+	model_name: "gpt-4.1",
+	provider: "openai",
+	call_type: "chat",
+	request_json: null,
+	response_json: null,
+	prompt_tokens: 10,
+	completion_tokens: 5,
+	total_cost_usd: 0.01,
+	latency_ms: 120,
+	is_error: 0,
+	error_message: null,
+	occurred_at: "2026-05-01T00:00:00.000Z",
+	received_at: "2026-05-01T00:00:01.000Z",
+	expires_at: "2026-05-02T00:00:00.000Z",
+};
+
+describe("GET /internal/ai/calls/:callId", () => {
+	it("returns the call with its trace and span ids", async () => {
+		const db = new MemSqlDb({
+			first: (sql, binds) =>
+				sql.includes("FROM ai_calls") && binds[1] === "call-1" ? row : null,
+		});
+		const res = await app.request("/internal/ai/calls/call-1", {}, {
+			DB: db,
+		} as unknown as CollectorEnv);
+		expect(res.status).toBe(200);
+		const body = (await res.json()) as {
+			call: { callId: string; modelName: string };
+			traceId: string;
+			spanId: string;
+		};
+		expect(body.call.callId).toBe("call-1");
+		expect(body.call.modelName).toBe("gpt-4.1");
+		expect(body.traceId).toBe("trace-1");
+		expect(body.spanId).toBe("span-1");
+		expect(db.calls[0].binds).toEqual(["default", "call-1"]);
+	});
+
+	it("answers 404 for an unknown call id", async () => {
+		const db = new MemSqlDb({ first: () => null });
+		const res = await app.request("/internal/ai/calls/nope", {}, {
+			DB: db,
+		} as unknown as CollectorEnv);
+		expect(res.status).toBe(404);
+	});
+});

package/src/plugins/ai-receiver.ts

@@ -97,6 +97,16 @@ export const aiReceiverPlugin: CollectorPlugin = {
 			return c.json(response);
 		});
 
+		// One AI call by its call id, with the trace/span it belongs to. Backs
+		// the `#/ai/calls/<id>` deep link when the call is outside the loaded list.
+		app.get("/internal/ai/calls/:callId", async (c) => {
+			const projectId = getProjectId(c);
+			const store = new AIStore(sqlDbFor(c.env));
+			const call = await store.getAICall(projectId, c.req.param("callId"));
+			if (!call) return c.json({ error: "AI call not found" }, 404);
+			return c.json({ call, traceId: call.traceId, spanId: call.spanId });
+		});
+
 		// OpenInference-kind spans (LLM/TOOL/RETRIEVER/CHAIN/AGENT/...) joined
 		// with their payload side-table. This is the replacement for the flat
 		// ai_calls endpoint — it returns typed spans that live inside the

package/src/plugins/autosre-routes.ts

@@ -4,6 +4,8 @@ import type {
 	ChangeEventKind,
 	CohortAttributionVerdict,
 	EvidenceEntityKind,
+	GrantCallbackDelivery,
+	GrantDeliveryResult,
 	InvestigationFindingInput,
 	JsonValue,
 	RemediationActionKind,
@@ -46,16 +48,19 @@ import {
 	evaluateRemediationWatchdogs,
 	failRemediationProposal,
 	getIncidentInvestigation,
+	getRemediationCallback,
 	getRemediationProposal,
 	listIncidentInvestigations,
 	listRemediationProposals,
 	openOrDeduplicateIncident,
 	proposeRemediationAction,
 	RemediationGateError,
+	recordCallbackDelivery,
 	rejectRemediationProposal,
 } from "../lib/autosre-remediation-gate";
 import { sha256Hex } from "../lib/hash";
 import { sqlDbFor } from "../lib/sql-db";
+import { assertSafeWebhookUrl } from "../lib/webhook-url";
 import { getProjectId } from "./_context";
 import { readJsonObject } from "./_json";
 
@@ -126,6 +131,12 @@ export const autosreRoutesPlugin: CollectorPlugin = {
 		 * `webhookUrl` (+ optional `secret`) in that same request and the token is
 		 * pushed to the runner over the SSRF-guarded, HMAC-signed incident webhook.
 		 * Without a `webhookUrl` the token is simply returned in the response.
+		 *
+		 * A `webhookUrl` (+ `secret`) given to `propose` for a proposal that is
+		 * parked for human approval is persisted on the proposal and used when
+		 * the approve request carries none. A callback on the approve request
+		 * wins over the stored one. The stored callback is cleared on approve
+		 * or reject, and only its host is ever returned by GET.
 		 */
 		const deliverGrant = async (
 			env: CollectorEnv | undefined,
@@ -139,23 +150,87 @@ export const autosreRoutesPlugin: CollectorPlugin = {
 				status: string;
 				grantToken?: string;
 			},
+			/** Callback persisted at propose time; used when the request has none. */
+			stored?: { url: string; secret?: string } | null,
 		) => {
-			const webhookUrl =
+			const bodyUrl =
 				typeof body.webhookUrl === "string" ? body.webhookUrl.trim() : "";
-			if (!webhookUrl || !proposal.grantToken) return undefined;
-			if (proposal.status !== "grant_issued") return undefined;
-			return dispatchIncidentWebhook(db, projectId, proposal.incidentId, {
-				url: webhookUrl,
-				secret: typeof body.secret === "string" ? body.secret : undefined,
-				environment: proposal.environment,
-				allowPrivateNetworks: env?.ALERT_WEBHOOK_ALLOW_PRIVATE === "true",
-				logger: runtime.logger,
-				grant: {
-					proposalId: proposal.id,
-					status: proposal.status,
-					grantToken: proposal.grantToken,
+			const target = bodyUrl
+				? {
+						url: bodyUrl,
+						secret: typeof body.secret === "string" ? body.secret : undefined,
+					}
+				: (stored ?? null);
+			const notAttempted: GrantDeliveryResult = {
+				attempted: false,
+				delivered: false,
+				attempts: 0,
+				host: null,
+			};
+			if (!target || !proposal.grantToken) {
+				return { webhookDelivery: undefined, grantDelivery: notAttempted };
+			}
+			if (proposal.status !== "grant_issued") {
+				return { webhookDelivery: undefined, grantDelivery: notAttempted };
+			}
+			let host: string | null = null;
+			try {
+				host = new URL(target.url).host || null;
+			} catch {
+				host = null;
+			}
+			const webhookDelivery = await dispatchIncidentWebhook(
+				db,
+				projectId,
+				proposal.incidentId,
+				{
+					url: target.url,
+					secret: target.secret,
+					environment: proposal.environment,
+					allowPrivateNetworks: env?.ALERT_WEBHOOK_ALLOW_PRIVATE === "true",
+					logger: runtime.logger,
+					grant: {
+						proposalId: proposal.id,
+						status: proposal.status,
+						grantToken: proposal.grantToken,
+					},
 				},
-			});
+			);
+			// Error text is surfaced to the human: strip anything URL-shaped and
+			// the secret so neither the query string nor the HMAC key can leak.
+			let error = webhookDelivery.error
+				? webhookDelivery.error.replace(
+						/\b[a-z][a-z0-9+.-]*:\/\/\S+/gi,
+						"<url>",
+					)
+				: undefined;
+			if (error && target.secret) {
+				error = error.split(target.secret).join("<redacted>");
+			}
+			const record = await recordCallbackDelivery(
+				db,
+				projectId,
+				proposal.environment,
+				proposal.id,
+				{
+					delivered: webhookDelivery.delivered,
+					attempts: webhookDelivery.attempts,
+					error,
+				},
+			);
+			(
+				proposal as { callbackDelivery?: GrantCallbackDelivery | null }
+			).callbackDelivery = record;
+			const grantDelivery: GrantDeliveryResult = {
+				attempted: true,
+				delivered: webhookDelivery.delivered,
+				attempts: webhookDelivery.attempts,
+				host,
+				...(webhookDelivery.delivered
+					? {}
+					: { error: error ?? "unknown error" }),
+			};
+			return { webhookDelivery, grantDelivery };
 		};
 
 		// 1. Change Ingestion (Ingest Auth /v1/changes)
@@ -585,6 +660,10 @@ export const autosreRoutesPlugin: CollectorPlugin = {
 			const db = sqlDbFor(c.env);
 			const input: InvestigationFindingInput = {
 				id: typeof body.id === "string" ? body.id : undefined,
+				idempotencyKey:
+					typeof body.idempotencyKey === "string" && body.idempotencyKey.trim()
+						? body.idempotencyKey.trim()
+						: undefined,
 				environment:
 					typeof body.environment === "string" ? body.environment : undefined,
 				incidentId:
@@ -633,6 +712,9 @@ export const autosreRoutesPlugin: CollectorPlugin = {
 							(id): id is string => typeof id === "string",
 						)
 					: [],
+				codeReferences: Array.isArray(body.codeReferences)
+					? (body.codeReferences as InvestigationFindingInput["codeReferences"])
+					: undefined,
 				agentRunId:
 					typeof body.agentRunId === "string" ? body.agentRunId : null,
 			};
@@ -702,6 +784,40 @@ export const autosreRoutesPlugin: CollectorPlugin = {
 			}
 		});
 
+		// Lightweight existence check so callers can validate counterfactual
+		// prerequisites before persisting a finding.
+		app.get("/internal/evals/runs/:id", async (c) => {
+			const projectId = getProjectId(c);
+			const runId = c.req.param("id");
+			const db = sqlDbFor(c.env);
+			const row = await db
+				.prepare(
+					`SELECT id, eval_case_id, service_version, commit_sha,
+					        pass_count, fail_count
+					 FROM eval_runs WHERE project_id = ? AND id = ? LIMIT 1`,
+				)
+				.bind(projectId, runId)
+				.first<{
+					id: string;
+					eval_case_id: string | null;
+					service_version: string | null;
+					commit_sha: string | null;
+					pass_count: number | null;
+					fail_count: number | null;
+				}>();
+			if (!row) return c.json({ error: "Eval run not found" }, 404);
+			return c.json({
+				run: {
+					id: row.id,
+					evalCaseId: row.eval_case_id,
+					serviceVersion: row.service_version,
+					commitSha: row.commit_sha,
+					passCount: Number(row.pass_count ?? 0),
+					failCount: Number(row.fail_count ?? 0),
+				},
+			});
+		});
+
 		// 6. Remediation Proposals, Human Approval, Claim Grant, Watchdog
 		app.get("/internal/remediations", async (c) => {
 			const projectId = getProjectId(c);
@@ -774,6 +890,22 @@ export const autosreRoutesPlugin: CollectorPlugin = {
 				: "autonomous_write";
 
 			const db = sqlDbFor(c.env);
+			const callbackUrl =
+				typeof body.webhookUrl === "string" ? body.webhookUrl.trim() : "";
+			if (callbackUrl) {
+				try {
+					assertSafeWebhookUrl(callbackUrl, {
+						allowPrivateNetworks: c.env?.ALERT_WEBHOOK_ALLOW_PRIVATE === "true",
+					});
+				} catch (err) {
+					return c.json(
+						{
+							error: `webhookUrl rejected: ${err instanceof Error ? err.message : String(err)}`,
+						},
+						400,
+					);
+				}
+			}
 			const input: RemediationProposalInput = {
 				environment:
 					typeof body.environment === "string" ? body.environment : undefined,
@@ -790,8 +922,17 @@ export const autosreRoutesPlugin: CollectorPlugin = {
 			try {
 				const proposal = await proposeRemediationAction(db, projectId, input, {
 					logger: runtime.logger,
+					callback: callbackUrl
+						? {
+								url: callbackUrl,
+								secret:
+									typeof body.secret === "string" && body.secret
+										? body.secret
+										: undefined,
+							}
+						: undefined,
 				});
-				const webhookDelivery = await deliverGrant(
+				const { webhookDelivery, grantDelivery } = await deliverGrant(
 					c.env,
 					db,
 					projectId,
@@ -803,6 +944,7 @@ export const autosreRoutesPlugin: CollectorPlugin = {
 						proposal,
 						...proposal,
 						grantToken: proposal.grantToken ?? null,
+						grantDelivery,
 						...(webhookDelivery ? { webhookDelivery } : {}),
 					},
 					201,
@@ -836,6 +978,13 @@ export const autosreRoutesPlugin: CollectorPlugin = {
 
 			const db = sqlDbFor(c.env);
 			try {
+				// Read before approving: the approve UPDATE clears the stored callback.
+				const storedCallback = await getRemediationCallback(
+					db,
+					projectId,
+					proposalId,
+					environment,
+				);
 				const proposal = await approveRemediationProposal(
 					db,
 					projectId,
@@ -845,17 +994,19 @@ export const autosreRoutesPlugin: CollectorPlugin = {
 						approvedByUserId,
 					},
 				);
-				const webhookDelivery = await deliverGrant(
+				const { webhookDelivery, grantDelivery } = await deliverGrant(
 					c.env,
 					db,
 					projectId,
 					body,
 					proposal,
+					storedCallback,
 				);
 				return c.json({
 					proposal,
 					...proposal,
 					grantToken: proposal.grantToken ?? null,
+					grantDelivery,
 					...(webhookDelivery ? { webhookDelivery } : {}),
 				});
 			} catch (err) {

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");
+	});
+});