@burdenoff/fluidgrids-fe-sdk 2026.1115.2 → 2026.1115.4

package/dist/{InsightsPage-DozSYGVD.js → InsightsPage-CoP1UTX6.js}

@@ -2,18 +2,18 @@
 import { t as __exportAll } from "./rolldown-runtime-hDbaFkMy.js";
 import { r as useTr } from "./TranslationBridge-Da-TPgQm.js";
 import { n as useNavigationV2 } from "./useNavigationV2-C2WeqN7d.js";
-import { t as TechnicalDetails } from "./TechnicalDetails-r5JXr1jZ.js";
-import { o as useRunReplayActions, r as useInsightsData } from "./useObservability-mXM7lCop.js";
-import { a as getTopFailingNodes, i as getFailureBreakdown, l as rankedFailingWorkflows, n as formatDuration, o as getTopFailingWorkflows, s as percentage, u as summarySuccessRate } from "./utils-C0dtnN4R.js";
-import { n as FailureTriagePanel } from "./FailureTriagePanel-Ddua9uxn.js";
-import { c as useContinuousOptimisationEnabled } from "./feature-flags-B_b8PJ6Z.js";
+import { t as TechnicalDetails } from "./TechnicalDetails-CMZwijEM.js";
+import { o as useRunReplayActions, r as useInsightsData } from "./useObservability-DadWpUTF.js";
+import { a as getFailureBreakdown, c as percentage, d as summarySuccessRate, n as formatDuration, o as getTopFailingNodes, r as formatMs, s as getTopFailingWorkflows, u as rankedFailingWorkflows } from "./utils-CXEodE1a.js";
+import { n as FailureTriagePanel } from "./FailureTriagePanel-Chvh8S_q.js";
+import { c as useContinuousOptimisationEnabled, l as useDurableFunctionNodesEnabled } from "./feature-flags-B_b8PJ6Z.js";
 import { i as SdkPermissionButton, s as useFluidGridsPermission, t as FLUIDGRIDS_PERMISSIONS } from "./constants-65QV61nQ.js";
-import { Hw as OptimisationKind, Uw as OptimisationSuggestionStatus, Vw as OptimisationDismissReason } from "./graphql-types-dS3Fk9Z5.js";
+import { Fj as TaskQueueAvailability, Hw as OptimisationDismissReason, Rv as InsightsRunKind, Uw as OptimisationKind, Ww as OptimisationSuggestionStatus } from "./graphql-types-BjCOnRUQ.js";
 import { n as getFluidGridsClient } from "./client-Ctl4jmY3.js";
 import { o as throwIfResultError } from "./errors-xPZ-IbQd.js";
 import { t as WorkflowProposalDocument } from "./WorkflowProposalDocument-BdUbsrd0.js";
-import { a as formatTokens, c as DISMISS_REASONS, f as monthlySavingLabel, i as aiSpendPeriod, l as evidenceFacts, p as shortRunId, r as aiCost, s as runsOfWorkflowPath, t as AI_SPEND_RANGE_DAYS, u as evidenceWindowDays } from "./ai-usage-Dit3U_aG.js";
-import { i as utcDay, r as runListPath } from "./run-list-links-CH-V4Li5.js";
+import { a as formatTokens, c as DISMISS_REASONS, f as monthlySavingLabel, i as aiSpendPeriod, l as evidenceFacts, p as shortRunId, r as aiCost, s as runsOfWorkflowPath, t as AI_SPEND_RANGE_DAYS, u as evidenceWindowDays } from "./ai-usage-BovljL6l.js";
+import { i as utcDay, r as runListPath } from "./run-list-links-DPWTtVr5.js";
 import { t as proposalCanvasPath } from "./useRequestedProposal-B7uPXfZB.js";
 import { useCallback, useEffect, useMemo, useRef, useState } from "react";
 import { Link, useNavigate } from "react-router";
@@ -24,6 +24,494 @@ import { Button, Dialog, DialogContent, DialogDescription, DialogFooter, DialogH
 import { Button as Button$1 } from "@burdenoff/fe-libs/button";
 import { BadgeDollarSign, DatabaseZap, Lightbulb, RotateCcw, Scissors, ShieldCheck, Timer } from "lucide-react";
 
+// src/generated/documents/wspace/CodeWorkflowInsightsDocument.ts
+const CodeWorkflowInsightsDocument = {
+	"kind": "Document",
+	"definitions": [{
+		"kind": "OperationDefinition",
+		"operation": "query",
+		"name": {
+			"kind": "Name",
+			"value": "CodeWorkflowInsights"
+		},
+		"variableDefinitions": [{
+			"kind": "VariableDefinition",
+			"variable": {
+				"kind": "Variable",
+				"name": {
+					"kind": "Name",
+					"value": "input"
+				}
+			},
+			"type": {
+				"kind": "NamedType",
+				"name": {
+					"kind": "Name",
+					"value": "CodeWorkflowInsightsInput"
+				}
+			},
+			"directives": []
+		}],
+		"directives": [],
+		"selectionSet": {
+			"kind": "SelectionSet",
+			"selections": [{
+				"kind": "Field",
+				"name": {
+					"kind": "Name",
+					"value": "codeWorkflowInsights"
+				},
+				"arguments": [{
+					"kind": "Argument",
+					"name": {
+						"kind": "Name",
+						"value": "input"
+					},
+					"value": {
+						"kind": "Variable",
+						"name": {
+							"kind": "Name",
+							"value": "input"
+						}
+					}
+				}],
+				"directives": [],
+				"selectionSet": {
+					"kind": "SelectionSet",
+					"selections": [
+						{
+							"kind": "Field",
+							"name": {
+								"kind": "Name",
+								"value": "startDate"
+							},
+							"arguments": [],
+							"directives": []
+						},
+						{
+							"kind": "Field",
+							"name": {
+								"kind": "Name",
+								"value": "endDate"
+							},
+							"arguments": [],
+							"directives": []
+						},
+						{
+							"kind": "Field",
+							"name": {
+								"kind": "Name",
+								"value": "runsByKind"
+							},
+							"arguments": [],
+							"directives": [],
+							"selectionSet": {
+								"kind": "SelectionSet",
+								"selections": [
+									{
+										"kind": "Field",
+										"name": {
+											"kind": "Name",
+											"value": "kind"
+										},
+										"arguments": [],
+										"directives": []
+									},
+									{
+										"kind": "Field",
+										"name": {
+											"kind": "Name",
+											"value": "total"
+										},
+										"arguments": [],
+										"directives": []
+									},
+									{
+										"kind": "Field",
+										"name": {
+											"kind": "Name",
+											"value": "completed"
+										},
+										"arguments": [],
+										"directives": []
+									},
+									{
+										"kind": "Field",
+										"name": {
+											"kind": "Name",
+											"value": "failed"
+										},
+										"arguments": [],
+										"directives": []
+									},
+									{
+										"kind": "Field",
+										"name": {
+											"kind": "Name",
+											"value": "open"
+										},
+										"arguments": [],
+										"directives": []
+									},
+									{
+										"kind": "Field",
+										"name": {
+											"kind": "Name",
+											"value": "cancelled"
+										},
+										"arguments": [],
+										"directives": []
+									}
+								]
+							}
+						},
+						{
+							"kind": "Field",
+							"name": {
+								"kind": "Name",
+								"value": "replay"
+							},
+							"arguments": [],
+							"directives": [],
+							"selectionSet": {
+								"kind": "SelectionSet",
+								"selections": [
+									{
+										"kind": "Field",
+										"name": {
+											"kind": "Name",
+											"value": "workflowTasks"
+										},
+										"arguments": [],
+										"directives": []
+									},
+									{
+										"kind": "Field",
+										"name": {
+											"kind": "Name",
+											"value": "failedWorkflowTasks"
+										},
+										"arguments": [],
+										"directives": []
+									},
+									{
+										"kind": "Field",
+										"name": {
+											"kind": "Name",
+											"value": "timedOutWorkflowTasks"
+										},
+										"arguments": [],
+										"directives": []
+									},
+									{
+										"kind": "Field",
+										"name": {
+											"kind": "Name",
+											"value": "eventsReplayed"
+										},
+										"arguments": [],
+										"directives": []
+									},
+									{
+										"kind": "Field",
+										"name": {
+											"kind": "Name",
+											"value": "avgEventsPerTask"
+										},
+										"arguments": [],
+										"directives": []
+									},
+									{
+										"kind": "Field",
+										"name": {
+											"kind": "Name",
+											"value": "avgTaskDurationMs"
+										},
+										"arguments": [],
+										"directives": []
+									},
+									{
+										"kind": "Field",
+										"name": {
+											"kind": "Name",
+											"value": "p95TaskDurationMs"
+										},
+										"arguments": [],
+										"directives": []
+									},
+									{
+										"kind": "Field",
+										"name": {
+											"kind": "Name",
+											"value": "maxHistoryLength"
+										},
+										"arguments": [],
+										"directives": []
+									},
+									{
+										"kind": "Field",
+										"name": {
+											"kind": "Name",
+											"value": "topWorkflows"
+										},
+										"arguments": [],
+										"directives": [],
+										"selectionSet": {
+											"kind": "SelectionSet",
+											"selections": [
+												{
+													"kind": "Field",
+													"name": {
+														"kind": "Name",
+														"value": "workflowKey"
+													},
+													"arguments": [],
+													"directives": []
+												},
+												{
+													"kind": "Field",
+													"name": {
+														"kind": "Name",
+														"value": "name"
+													},
+													"arguments": [],
+													"directives": []
+												},
+												{
+													"kind": "Field",
+													"name": {
+														"kind": "Name",
+														"value": "workflowTasks"
+													},
+													"arguments": [],
+													"directives": []
+												},
+												{
+													"kind": "Field",
+													"name": {
+														"kind": "Name",
+														"value": "eventsReplayed"
+													},
+													"arguments": [],
+													"directives": []
+												},
+												{
+													"kind": "Field",
+													"name": {
+														"kind": "Name",
+														"value": "avgTaskDurationMs"
+													},
+													"arguments": [],
+													"directives": []
+												}
+											]
+										}
+									}
+								]
+							}
+						},
+						{
+							"kind": "Field",
+							"name": {
+								"kind": "Name",
+								"value": "determinism"
+							},
+							"arguments": [],
+							"directives": [],
+							"selectionSet": {
+								"kind": "SelectionSet",
+								"selections": [
+									{
+										"kind": "Field",
+										"name": {
+											"kind": "Name",
+											"value": "violatingRuns"
+										},
+										"arguments": [],
+										"directives": []
+									},
+									{
+										"kind": "Field",
+										"name": {
+											"kind": "Name",
+											"value": "openViolatingRuns"
+										},
+										"arguments": [],
+										"directives": []
+									},
+									{
+										"kind": "Field",
+										"name": {
+											"kind": "Name",
+											"value": "topWorkflows"
+										},
+										"arguments": [],
+										"directives": [],
+										"selectionSet": {
+											"kind": "SelectionSet",
+											"selections": [
+												{
+													"kind": "Field",
+													"name": {
+														"kind": "Name",
+														"value": "workflowKey"
+													},
+													"arguments": [],
+													"directives": []
+												},
+												{
+													"kind": "Field",
+													"name": {
+														"kind": "Name",
+														"value": "name"
+													},
+													"arguments": [],
+													"directives": []
+												},
+												{
+													"kind": "Field",
+													"name": {
+														"kind": "Name",
+														"value": "runs"
+													},
+													"arguments": [],
+													"directives": []
+												},
+												{
+													"kind": "Field",
+													"name": {
+														"kind": "Name",
+														"value": "openRuns"
+													},
+													"arguments": [],
+													"directives": []
+												},
+												{
+													"kind": "Field",
+													"name": {
+														"kind": "Name",
+														"value": "lastViolationAt"
+													},
+													"arguments": [],
+													"directives": []
+												}
+											]
+										}
+									}
+								]
+							}
+						}
+					]
+				}
+			}]
+		}
+	}]
+};
+
+// src/generated/documents/wspace/TaskQueueAvailabilityDocument.ts
+const TaskQueueAvailabilityDocument = {
+	"kind": "Document",
+	"definitions": [{
+		"kind": "OperationDefinition",
+		"operation": "query",
+		"name": {
+			"kind": "Name",
+			"value": "TaskQueueAvailability"
+		},
+		"variableDefinitions": [],
+		"directives": [],
+		"selectionSet": {
+			"kind": "SelectionSet",
+			"selections": [{
+				"kind": "Field",
+				"name": {
+					"kind": "Name",
+					"value": "taskQueueAvailability"
+				},
+				"arguments": [],
+				"directives": [],
+				"selectionSet": {
+					"kind": "SelectionSet",
+					"selections": [
+						{
+							"kind": "Field",
+							"name": {
+								"kind": "Name",
+								"value": "name"
+							},
+							"arguments": [],
+							"directives": []
+						},
+						{
+							"kind": "Field",
+							"name": {
+								"kind": "Name",
+								"value": "kind"
+							},
+							"arguments": [],
+							"directives": []
+						},
+						{
+							"kind": "Field",
+							"name": {
+								"kind": "Name",
+								"value": "environments"
+							},
+							"arguments": [],
+							"directives": []
+						},
+						{
+							"kind": "Field",
+							"name": {
+								"kind": "Name",
+								"value": "availability"
+							},
+							"arguments": [],
+							"directives": []
+						},
+						{
+							"kind": "Field",
+							"name": {
+								"kind": "Name",
+								"value": "pollers"
+							},
+							"arguments": [],
+							"directives": []
+						},
+						{
+							"kind": "Field",
+							"name": {
+								"kind": "Name",
+								"value": "workflowBacklog"
+							},
+							"arguments": [],
+							"directives": []
+						},
+						{
+							"kind": "Field",
+							"name": {
+								"kind": "Name",
+								"value": "activityBacklog"
+							},
+							"arguments": [],
+							"directives": []
+						},
+						{
+							"kind": "Field",
+							"name": {
+								"kind": "Name",
+								"value": "oldestBacklogAgeSeconds"
+							},
+							"arguments": [],
+							"directives": []
+						}
+					]
+				}
+			}]
+		}
+	}]
+};
+
 // src/generated/documents/wspace/ErrorAnalyticsDocument.ts
 const ErrorAnalyticsDocument = {
 	"kind": "Document",
@@ -2954,7 +3442,7 @@ function useContinuousOptimisation(active) {
 
 // src/modules/observability/optimisation-labels.ts
 /** The kind's short label, e.g. "Raise the node timeout". */
-function kindLabel(tr, kind) {
+function kindLabel$1(tr, kind) {
 	switch (kind) {
 		case "ADD_RETRY": return tr("fluidgrids.optimisation.kind.ADD_RETRY", "Retry transient failures");
 		case "CHEAPER_MODEL": return tr("fluidgrids.optimisation.kind.CHEAPER_MODEL", "Use a cheaper model");
@@ -3216,7 +3704,7 @@ function OptimisationSuggestionRow({ suggestion, pending, onOpenRun, onApply, on
 						children: [
 							/* @__PURE__ */ jsxs("span", {
 								className: "inline-flex items-center gap-1 rounded-full bg-surface px-2 py-0.5 text-xs text-text-secondary",
-								children: [/* @__PURE__ */ jsx(KindIcon, { className: "size-3.5" }), kindLabel(tr, kind)]
+								children: [/* @__PURE__ */ jsx(KindIcon, { className: "size-3.5" }), kindLabel$1(tr, kind)]
 							}),
 							/* @__PURE__ */ jsx("span", {
 								className: "font-medium text-text-primary",
@@ -3444,7 +3932,7 @@ function useWorkspaceAiUsage(days) {
 * reads "Not priced yet", never "$0.00". Each row opens the Runs list
 * filtered to that workflow.
 */
-function rangeLabel(days, tr) {
+function rangeLabel$1(days, tr) {
 	switch (days) {
 		case 7: return tr("fluidgrids.insights.aiSpend.range7", "7 days");
 		case 30: return tr("fluidgrids.insights.aiSpend.range30", "30 days");
@@ -3476,7 +3964,7 @@ function AiSpendPanel() {
 			}), /* @__PURE__ */ jsx("p", {
 				className: "mt-1 text-sm text-text-secondary",
 				children: tr("fluidgrids.insights.aiSpend.subtitle", "Model calls made by your workflow runs, most expensive workflow first.")
-			})] }), /* @__PURE__ */ jsx(RangeSelector, {
+			})] }), /* @__PURE__ */ jsx(RangeSelector$1, {
 				days,
 				onChange: setDays,
 				tr
@@ -3490,7 +3978,7 @@ function AiSpendPanel() {
 		})]
 	});
 }
-function RangeSelector({ days, onChange, tr }) {
+function RangeSelector$1({ days, onChange, tr }) {
 	return /* @__PURE__ */ jsx("div", {
 		className: "flex shrink-0 gap-1 rounded-lg border border-border-default p-1",
 		role: "group",
@@ -3500,7 +3988,7 @@ function RangeSelector({ days, onChange, tr }) {
 			"aria-pressed": days === option,
 			onClick: () => onChange(option),
 			className: `rounded px-3 py-1 text-sm ${days === option ? "bg-action-primary-bg text-action-primary-text" : "text-text-secondary hover:text-text-primary"}`,
-			children: rangeLabel(option, tr)
+			children: rangeLabel$1(option, tr)
 		}, option))
 	});
 }
@@ -3910,6 +4398,503 @@ function ErrorAnalyticsPanel({ analytics, period, loading, error, onRetry }) {
 	});
 }
 
+// src/modules/observability/hooks/useCodeWorkflowInsights.ts
+/**
+* useCodeWorkflowInsights / useTaskQueueAvailability — the reads behind the
+* Insights "Code workflows" panel (gap G21, spec code-first 09 §5).
+*
+* - `codeWorkflowInsights(input)` (dashboard:read): runs by kind, replay cost
+*   and determinism violations over the last 7, 30 or 90 days.
+* - `taskQueueAvailability` (task-queue:read): whether each task queue has
+*   workers right now.
+*
+* Each is a plain network read per period and refresh; they load and fail
+* independently, so a member without task-queue:read still sees the run
+* figures. Nothing is read while `enabled` is false.
+*/
+/** The periods the panel offers, in days; the service allows up to 90. */
+const CODE_INSIGHTS_RANGE_DAYS = [
+	7,
+	30,
+	90
+];
+/** Rows per ranking (replay cost and determinism). */
+const CODE_INSIGHTS_LIMIT = 5;
+const DAY_MS = 864e5;
+/** The window ending `now`, `days` long, as the query input wants it. */
+function codeInsightsWindow(days, now) {
+	return {
+		startDate: (/* @__PURE__ */ new Date(now.getTime() - days * DAY_MS)).toISOString(),
+		endDate: now.toISOString()
+	};
+}
+async function fetchCodeWorkflowInsights(days, now = /* @__PURE__ */ new Date()) {
+	const result = await getFluidGridsClient().query({
+		query: CodeWorkflowInsightsDocument,
+		variables: { input: {
+			...codeInsightsWindow(days, now),
+			limit: 5
+		} },
+		fetchPolicy: "network-only"
+	});
+	throwIfResultError(result);
+	return result.data?.codeWorkflowInsights ?? null;
+}
+async function fetchTaskQueueAvailability() {
+	const result = await getFluidGridsClient().query({
+		query: TaskQueueAvailabilityDocument,
+		fetchPolicy: "network-only"
+	});
+	throwIfResultError(result);
+	return result.data?.taskQueueAvailability ?? [];
+}
+/**
+* The latest answer of `load`, re-read whenever `load` changes and on
+* `refetch`. An older read that settles after a newer one was sent is
+* dropped; a failed refresh keeps the last good data on screen.
+*/
+function useLatestRead(load, enabled) {
+	const [sent, setSent] = useState(0);
+	const [settled, setSettled] = useState(null);
+	const request = useRef(0);
+	const read = useCallback(async () => {
+		if (!enabled) return;
+		const id = ++request.current;
+		setSent(id);
+		let data = null;
+		let error = null;
+		try {
+			data = await load();
+		} catch (err) {
+			error = err instanceof Error ? err.message : String(err);
+		}
+		if (id !== request.current) return;
+		setSettled((previous) => ({
+			request: id,
+			data: error ? previous?.data ?? null : data,
+			error
+		}));
+	}, [enabled, load]);
+	useEffect(() => {
+		read();
+	}, [read]);
+	return {
+		data: settled?.data ?? null,
+		loading: enabled && (settled?.request ?? -1) !== sent,
+		error: settled?.error ?? null,
+		refetch: read
+	};
+}
+function useCodeWorkflowInsights(days, enabled) {
+	return useLatestRead(useCallback(() => fetchCodeWorkflowInsights(days), [days]), enabled);
+}
+function useTaskQueueAvailability(enabled) {
+	return useLatestRead(fetchTaskQueueAvailability, enabled);
+}
+
+// src/modules/observability/components/CodeWorkflowsPanel.tsx
+/**
+* Insights: Code workflows (gap G21, spec code-first 09 §5). How the
+* workspace's runs split between canvas runs, code workflows and standalone
+* activities; what replaying code workflows costs (the history each workflow
+* task replays and how long tasks take); determinism violations, with the
+* runs still stuck on one; and whether each task queue has workers now.
+*
+* Rendered by Insights only while fluidgrids.code-first and
+* fluidgrids.durable-functions are on. Worker availability needs
+* task-queue:read and loads on its own, so a member without it still sees
+* the run figures.
+*/
+/** A count that may be fractional (events replayed) as a whole number. */
+function formatCount(value) {
+	return Math.round(value).toLocaleString();
+}
+function rangeLabel(days, tr) {
+	switch (days) {
+		case 7: return tr("fluidgrids.insights.codeWorkflows.range7", "7 days");
+		case 30: return tr("fluidgrids.insights.codeWorkflows.range30", "30 days");
+		case 90: return tr("fluidgrids.insights.codeWorkflows.range90", "90 days");
+	}
+}
+function kindLabel(kind, tr) {
+	switch (kind) {
+		case "GRAPH": return tr("fluidgrids.insights.codeWorkflows.kindGraph", "Canvas runs");
+		case "CODE_WORKFLOW": return tr("fluidgrids.insights.codeWorkflows.kindCode", "Code workflows");
+		case "STANDALONE_ACTIVITY": return tr("fluidgrids.insights.codeWorkflows.kindActivity", "Standalone activities");
+	}
+}
+function kindIcon(kind) {
+	switch (kind) {
+		case "GRAPH": return "mdi:graph-outline";
+		case "CODE_WORKFLOW": return "mdi:code-braces";
+		case "STANDALONE_ACTIVITY": return "mdi:lightning-bolt-outline";
+	}
+}
+function CodeWorkflowsPanel({ canReadQueues }) {
+	const tr = useTr();
+	const [days, setDays] = useState(30);
+	const insights = useCodeWorkflowInsights(days, true);
+	const queues = useTaskQueueAvailability(canReadQueues);
+	return /* @__PURE__ */ jsxs("section", {
+		className: "rounded-xl border border-border-default bg-surface p-4 sm:p-5",
+		"aria-label": tr("fluidgrids.insights.codeWorkflows.title", "Code workflows"),
+		"data-testid": "insights-code-workflows",
+		children: [
+			/* @__PURE__ */ jsxs("div", {
+				className: "flex flex-col gap-3 sm:flex-row sm:items-start sm:justify-between",
+				children: [/* @__PURE__ */ jsxs("div", { children: [/* @__PURE__ */ jsx("h2", {
+					className: "text-base font-semibold text-text-primary",
+					children: tr("fluidgrids.insights.codeWorkflows.title", "Code workflows")
+				}), /* @__PURE__ */ jsx("p", {
+					className: "mt-1 text-sm text-text-secondary",
+					children: tr("fluidgrids.insights.codeWorkflows.subtitle", "Runs by kind, what replaying code workflows costs, determinism violations and worker availability.")
+				})] }), /* @__PURE__ */ jsxs("div", {
+					className: "flex shrink-0 items-center gap-2",
+					children: [/* @__PURE__ */ jsx(RangeSelector, {
+						days,
+						onChange: setDays,
+						tr
+					}), /* @__PURE__ */ jsx(Button$1, {
+						variant: "outline",
+						size: "sm",
+						onClick: () => {
+							insights.refetch();
+							if (canReadQueues) queues.refetch();
+						},
+						disabled: insights.loading,
+						"aria-label": tr("fluidgrids.insights.codeWorkflows.refresh", "Refresh code workflow insights"),
+						children: /* @__PURE__ */ jsx(Icon, {
+							icon: "mdi:refresh",
+							width: 16
+						})
+					})]
+				})]
+			}),
+			/* @__PURE__ */ jsx(InsightsBody, {
+				data: insights.data,
+				loading: insights.loading,
+				error: insights.error,
+				onRetry: () => void insights.refetch(),
+				tr
+			}),
+			canReadQueues && /* @__PURE__ */ jsx(WorkerAvailability, {
+				queues: queues.data,
+				loading: queues.loading,
+				error: queues.error,
+				onRetry: () => void queues.refetch(),
+				tr
+			})
+		]
+	});
+}
+function RangeSelector({ days, onChange, tr }) {
+	return /* @__PURE__ */ jsx("div", {
+		className: "flex gap-1 rounded-lg border border-border-default p-1",
+		role: "group",
+		"aria-label": tr("fluidgrids.insights.codeWorkflows.rangeLabel", "Period"),
+		children: CODE_INSIGHTS_RANGE_DAYS.map((option) => /* @__PURE__ */ jsx("button", {
+			type: "button",
+			"aria-pressed": days === option,
+			onClick: () => onChange(option),
+			className: `rounded px-3 py-1 text-sm ${days === option ? "bg-action-primary-bg text-action-primary-text" : "text-text-secondary hover:text-text-primary"}`,
+			children: rangeLabel(option, tr)
+		}, option))
+	});
+}
+function ErrorNotice({ message, label, onRetry, tr }) {
+	return /* @__PURE__ */ jsxs("div", {
+		className: "mt-4 rounded-lg border border-status-error-border bg-status-error-bg-subtle p-4 text-sm text-status-error-text",
+		role: "alert",
+		children: [
+			/* @__PURE__ */ jsx("p", {
+				className: "font-medium",
+				children: label
+			}),
+			/* @__PURE__ */ jsx("p", {
+				className: "mt-1",
+				children: message
+			}),
+			/* @__PURE__ */ jsx(Button$1, {
+				variant: "outline",
+				size: "sm",
+				className: "mt-3",
+				onClick: onRetry,
+				children: tr("fluidgrids.insights.codeWorkflows.retry", "Try again")
+			})
+		]
+	});
+}
+function InsightsBody({ data, loading, error, onRetry, tr }) {
+	if (error && !data) return /* @__PURE__ */ jsx(ErrorNotice, {
+		message: error,
+		label: tr("fluidgrids.insights.codeWorkflows.loadError", "Could not load code workflow insights"),
+		onRetry,
+		tr
+	});
+	if (!data) return /* @__PURE__ */ jsx("div", {
+		className: "mt-4 grid gap-3 sm:grid-cols-3",
+		"aria-busy": loading,
+		"data-testid": "insights-code-workflows-loading",
+		children: [
+			1,
+			2,
+			3
+		].map((item) => /* @__PURE__ */ jsx("div", { className: "h-20 animate-pulse rounded-lg border border-border-default bg-surface-sunken" }, item))
+	});
+	return /* @__PURE__ */ jsxs("div", {
+		className: "mt-4 space-y-5",
+		children: [
+			/* @__PURE__ */ jsx(RunsByKind, {
+				kinds: data.runsByKind,
+				tr
+			}),
+			/* @__PURE__ */ jsx(ReplayCost, {
+				replay: data.replay,
+				tr
+			}),
+			/* @__PURE__ */ jsx(Determinism, {
+				determinism: data.determinism,
+				tr
+			})
+		]
+	});
+}
+function RunsByKind({ kinds, tr }) {
+	return /* @__PURE__ */ jsx("ul", {
+		className: "m-0 grid list-none gap-3 p-0 sm:grid-cols-3",
+		"aria-label": tr("fluidgrids.insights.codeWorkflows.byKind", "Runs by kind"),
+		"data-testid": "insights-code-runs-by-kind",
+		children: kinds.map((kind) => /* @__PURE__ */ jsxs("li", {
+			className: "rounded-lg border border-border-default p-3",
+			"data-testid": `insights-code-kind-${kind.kind}`,
+			children: [
+				/* @__PURE__ */ jsxs("div", {
+					className: "flex items-center gap-2 text-sm text-text-secondary",
+					children: [/* @__PURE__ */ jsx(Icon, {
+						icon: kindIcon(kind.kind),
+						width: 16
+					}), /* @__PURE__ */ jsx("span", { children: kindLabel(kind.kind, tr) })]
+				}),
+				/* @__PURE__ */ jsx("p", {
+					className: "mt-2 text-xl font-semibold text-text-primary",
+					children: kind.total.toLocaleString()
+				}),
+				/* @__PURE__ */ jsx("p", {
+					className: "mt-1 text-xs text-text-secondary",
+					children: tr("fluidgrids.insights.codeWorkflows.kindBreakdown", "{{completed}} completed · {{failed}} failed · {{open}} open · {{cancelled}} cancelled", {
+						completed: kind.completed.toLocaleString(),
+						failed: kind.failed.toLocaleString(),
+						open: kind.open.toLocaleString(),
+						cancelled: kind.cancelled.toLocaleString()
+					})
+				})
+			]
+		}, kind.kind))
+	});
+}
+function Stat({ label, value, detail, testId }) {
+	return /* @__PURE__ */ jsxs("div", {
+		"data-testid": testId,
+		children: [
+			/* @__PURE__ */ jsx("p", {
+				className: "text-xs text-text-secondary",
+				children: label
+			}),
+			/* @__PURE__ */ jsx("p", {
+				className: "mt-1 text-lg font-semibold text-text-primary",
+				children: value
+			}),
+			detail && /* @__PURE__ */ jsx("p", {
+				className: "text-xs text-text-secondary",
+				children: detail
+			})
+		]
+	});
+}
+function ReplayCost({ replay, tr }) {
+	const failures = replay.failedWorkflowTasks + replay.timedOutWorkflowTasks;
+	return /* @__PURE__ */ jsxs("div", {
+		"data-testid": "insights-code-replay",
+		children: [
+			/* @__PURE__ */ jsx("h3", {
+				className: "text-sm font-semibold text-text-primary",
+				children: tr("fluidgrids.insights.codeWorkflows.replayTitle", "Replay cost")
+			}),
+			/* @__PURE__ */ jsx("p", {
+				className: "mt-0.5 text-xs text-text-secondary",
+				children: tr("fluidgrids.insights.codeWorkflows.replayHelp", "Each workflow task replays the run's history from the start. Long histories make every task slower; continue-as-new keeps them short.")
+			}),
+			/* @__PURE__ */ jsxs("div", {
+				className: "mt-3 grid grid-cols-2 gap-4 lg:grid-cols-4",
+				children: [
+					/* @__PURE__ */ jsx(Stat, {
+						label: tr("fluidgrids.insights.codeWorkflows.workflowTasks", "Workflow tasks"),
+						value: replay.workflowTasks.toLocaleString(),
+						detail: failures > 0 ? tr("fluidgrids.insights.codeWorkflows.taskFailures", "{{failed}} failed · {{timedOut}} timed out", {
+							failed: replay.failedWorkflowTasks.toLocaleString(),
+							timedOut: replay.timedOutWorkflowTasks.toLocaleString()
+						}) : void 0,
+						testId: "insights-code-workflow-tasks"
+					}),
+					/* @__PURE__ */ jsx(Stat, {
+						label: tr("fluidgrids.insights.codeWorkflows.eventsReplayed", "Events replayed"),
+						value: formatCount(replay.eventsReplayed),
+						detail: replay.avgEventsPerTask != null ? tr("fluidgrids.insights.codeWorkflows.eventsPerTask", "{{count}} per task on average", { count: replay.avgEventsPerTask.toFixed(1) }) : void 0,
+						testId: "insights-code-events-replayed"
+					}),
+					/* @__PURE__ */ jsx(Stat, {
+						label: tr("fluidgrids.insights.codeWorkflows.taskTime", "Task time (avg / p95)"),
+						value: `${formatMs(replay.avgTaskDurationMs)} / ${formatMs(replay.p95TaskDurationMs)}`,
+						testId: "insights-code-task-time"
+					}),
+					/* @__PURE__ */ jsx(Stat, {
+						label: tr("fluidgrids.insights.codeWorkflows.longestHistory", "Longest history"),
+						value: tr("fluidgrids.insights.codeWorkflows.events", "{{count}} events", { count: replay.maxHistoryLength.toLocaleString() }),
+						testId: "insights-code-longest-history"
+					})
+				]
+			}),
+			replay.topWorkflows.length > 0 ? /* @__PURE__ */ jsx("ul", {
+				className: "mt-3 divide-y divide-border-default rounded-lg border border-border-default",
+				"aria-label": tr("fluidgrids.insights.codeWorkflows.replayRanking", "Workflows that replayed the most"),
+				children: replay.topWorkflows.map((row) => /* @__PURE__ */ jsxs("li", {
+					className: "flex flex-col gap-1 px-3 py-2 text-sm sm:flex-row sm:items-center sm:gap-4",
+					children: [/* @__PURE__ */ jsx(Link, {
+						to: runsOfWorkflowPath(row.workflowKey),
+						className: "min-w-0 flex-1 truncate font-medium text-text-link hover:underline",
+						children: row.name || row.workflowKey
+					}), /* @__PURE__ */ jsx("span", {
+						className: "text-xs text-text-secondary",
+						children: tr("fluidgrids.insights.codeWorkflows.replayRow", "{{tasks}} tasks · {{events}} events · {{time}} avg", {
+							tasks: row.workflowTasks.toLocaleString(),
+							events: formatCount(row.eventsReplayed),
+							time: formatMs(row.avgTaskDurationMs)
+						})
+					})]
+				}, row.workflowKey))
+			}) : /* @__PURE__ */ jsx("p", {
+				className: "mt-3 text-sm text-text-secondary",
+				children: tr("fluidgrids.insights.codeWorkflows.noTasks", "No code workflow ran a task in this period.")
+			})
+		]
+	});
+}
+function Determinism({ determinism, tr }) {
+	const clean = determinism.violatingRuns === 0;
+	return /* @__PURE__ */ jsxs("div", {
+		"data-testid": "insights-code-determinism",
+		children: [
+			/* @__PURE__ */ jsxs("div", {
+				className: "flex items-center gap-2",
+				children: [/* @__PURE__ */ jsx(Icon, {
+					icon: clean ? "mdi:check-circle-outline" : "mdi:alert-outline",
+					width: 18,
+					className: clean ? "text-status-success-text" : "text-status-warning-text"
+				}), /* @__PURE__ */ jsx("h3", {
+					className: "text-sm font-semibold text-text-primary",
+					children: tr("fluidgrids.insights.codeWorkflows.determinismTitle", "Determinism violations")
+				})]
+			}),
+			/* @__PURE__ */ jsx("p", {
+				className: "mt-1 text-sm text-text-secondary",
+				"data-testid": "insights-code-determinism-summary",
+				children: clean ? tr("fluidgrids.insights.codeWorkflows.noViolations", "No run hit a determinism violation in this period.") : tr("fluidgrids.insights.codeWorkflows.violations", "{{runs}} runs hit a determinism violation; {{open}} are still retrying until a fixed version is deployed.", {
+					runs: determinism.violatingRuns.toLocaleString(),
+					open: determinism.openViolatingRuns.toLocaleString()
+				})
+			}),
+			determinism.topWorkflows.length > 0 && /* @__PURE__ */ jsx("ul", {
+				className: "mt-2 divide-y divide-border-default rounded-lg border border-border-default",
+				children: determinism.topWorkflows.map((row) => /* @__PURE__ */ jsxs("li", {
+					className: "flex flex-col gap-1 px-3 py-2 text-sm sm:flex-row sm:items-center sm:gap-4",
+					children: [/* @__PURE__ */ jsx(Link, {
+						to: runsOfWorkflowPath(row.workflowKey),
+						className: "min-w-0 flex-1 truncate font-medium text-text-link hover:underline",
+						children: row.name || row.workflowKey
+					}), /* @__PURE__ */ jsx("span", {
+						className: "text-xs text-text-secondary",
+						children: tr("fluidgrids.insights.codeWorkflows.violationRow", "{{runs}} runs · {{open}} open · last {{when}}", {
+							runs: row.runs.toLocaleString(),
+							open: row.openRuns.toLocaleString(),
+							when: new Date(row.lastViolationAt).toLocaleString()
+						})
+					})]
+				}, row.workflowKey))
+			})
+		]
+	});
+}
+function availabilityLabel(availability, tr) {
+	switch (availability) {
+		case "MANAGED": return tr("fluidgrids.insights.codeWorkflows.queueManaged", "Managed");
+		case "AVAILABLE": return tr("fluidgrids.insights.codeWorkflows.queueAvailable", "Workers online");
+		case "UNAVAILABLE": return tr("fluidgrids.insights.codeWorkflows.queueUnavailable", "No workers, tasks waiting");
+		case "IDLE": return tr("fluidgrids.insights.codeWorkflows.queueIdle", "No workers");
+		case "UNKNOWN": return tr("fluidgrids.insights.codeWorkflows.queueUnknown", "Unknown");
+	}
+}
+function availabilityClass(availability) {
+	switch (availability) {
+		case "MANAGED":
+		case "AVAILABLE": return "bg-status-success-bg-subtle text-status-success-text";
+		case "UNAVAILABLE": return "bg-status-error-bg-subtle text-status-error-text";
+		case "IDLE": return "bg-status-warning-bg-subtle text-status-warning-text";
+		case "UNKNOWN": return "bg-surface-sunken text-text-secondary";
+	}
+}
+function WorkerAvailability({ queues, loading, error, onRetry, tr }) {
+	return /* @__PURE__ */ jsxs("div", {
+		className: "mt-5",
+		"data-testid": "insights-code-workers",
+		children: [
+			/* @__PURE__ */ jsx("h3", {
+				className: "text-sm font-semibold text-text-primary",
+				children: tr("fluidgrids.insights.codeWorkflows.workersTitle", "Worker availability")
+			}),
+			/* @__PURE__ */ jsx("p", {
+				className: "mt-0.5 text-xs text-text-secondary",
+				children: tr("fluidgrids.insights.codeWorkflows.workersHelp", "Right now, per task queue. A self-hosted queue has workers when one polled it in the last two minutes.")
+			}),
+			error && !queues ? /* @__PURE__ */ jsx(ErrorNotice, {
+				message: error,
+				label: tr("fluidgrids.insights.codeWorkflows.workersError", "Could not load worker availability"),
+				onRetry,
+				tr
+			}) : !queues ? /* @__PURE__ */ jsx("div", {
+				className: "mt-3 h-12 animate-pulse rounded-lg border border-border-default bg-surface-sunken",
+				"aria-busy": loading
+			}) : /* @__PURE__ */ jsx("ul", {
+				className: "mt-3 divide-y divide-border-default rounded-lg border border-border-default",
+				children: queues.map((queue) => /* @__PURE__ */ jsxs("li", {
+					className: "flex flex-col gap-1 px-3 py-2 text-sm sm:flex-row sm:items-center sm:gap-4",
+					"data-testid": "insights-code-queue",
+					children: [
+						/* @__PURE__ */ jsxs("span", {
+							className: "min-w-0 flex-1 truncate font-medium text-text-primary",
+							children: [queue.name, queue.environments.length > 0 && /* @__PURE__ */ jsx("span", {
+								className: "ml-2 text-xs font-normal text-text-secondary",
+								children: queue.environments.join(", ")
+							})]
+						}),
+						/* @__PURE__ */ jsx("span", {
+							className: "text-xs text-text-secondary",
+							children: tr("fluidgrids.insights.codeWorkflows.queueRow", "{{pollers}} workers · {{waiting}} waiting · oldest {{age}}", {
+								pollers: queue.pollers.toLocaleString(),
+								waiting: (queue.workflowBacklog + queue.activityBacklog).toLocaleString(),
+								age: formatDuration(queue.oldestBacklogAgeSeconds)
+							})
+						}),
+						/* @__PURE__ */ jsx("span", {
+							className: `w-fit rounded-full px-2 py-0.5 text-xs ${availabilityClass(queue.availability)}`,
+							children: availabilityLabel(queue.availability, tr)
+						})
+					]
+				}, queue.name))
+			})
+		]
+	});
+}
+
 // src/modules/observability/hooks/useErrorAnalytics.ts
 /**
 * useErrorAnalytics — the workspace's failed runs over the last
@@ -4024,6 +5009,8 @@ function InsightsPage({ showErrors = false }) {
 	const { retryRun, retryFromTriage, retryLoading } = useInsightsRetry();
 	const { allowed: canManageTriage } = useFluidGridsPermission(FLUIDGRIDS_PERMISSIONS.WORKFLOW_PUBLISH);
 	const { allowed: canRetryRuns } = useFluidGridsPermission(FLUIDGRIDS_PERMISSIONS.WORKFLOW_RUN_EXECUTE);
+	const codeWorkflowsEnabled = useDurableFunctionNodesEnabled();
+	const { allowed: canReadQueues } = useFluidGridsPermission(FLUIDGRIDS_PERMISSIONS.TASK_QUEUE_READ);
 	const [activeTab, setActiveTab] = useState(showErrors ? "errors" : "overview");
 	const errorAnalytics = useErrorAnalytics(activeTab === "errors");
 	const failureBreakdown = useMemo(() => getFailureBreakdown(failedRuns), [failedRuns]);
@@ -4081,6 +5068,10 @@ function InsightsPage({ showErrors = false }) {
 				onOpenRun: (runId) => navigate(`../runs/${runId}`),
 				onOpenProposal: (target) => navigate(`../${proposalCanvasPath(target.workflowKey, target.version, target.proposalId)}`)
 			}),
+			activeTab === "overview" && codeWorkflowsEnabled && /* @__PURE__ */ jsx("div", {
+				className: "mb-6",
+				children: /* @__PURE__ */ jsx(CodeWorkflowsPanel, { canReadQueues })
+			}),
 			activeTab === "overview" && /* @__PURE__ */ jsx("div", {
 				className: "mb-6",
 				children: /* @__PURE__ */ jsx(AiSpendPanel, {})
@@ -4440,4 +5431,4 @@ function ErrorAnalyticsPage() {
 	return /* @__PURE__ */ jsx(InsightsPage, { showErrors: true });
 }
 
-export { ContinuousOptimisationSettingsDocument as a, ProposeOptimisationDocument as c, WorkspaceAiUsageDocument as d, ErrorAnalyticsDocument as f, OptimisationSuggestionsDocument as i, FgRunOptimisationScanDocument as l, InsightsPage as n, SnoozeOptimisationSuggestionDocument as o, InsightsPage_exports as r, SetContinuousOptimisationEnabledDocument as s, ErrorAnalyticsPage as t, DismissOptimisationSuggestionDocument as u };
+export { ContinuousOptimisationSettingsDocument as a, ProposeOptimisationDocument as c, WorkspaceAiUsageDocument as d, ErrorAnalyticsDocument as f, OptimisationSuggestionsDocument as i, FgRunOptimisationScanDocument as l, CodeWorkflowInsightsDocument as m, InsightsPage as n, SnoozeOptimisationSuggestionDocument as o, TaskQueueAvailabilityDocument as p, InsightsPage_exports as r, SetContinuousOptimisationEnabledDocument as s, ErrorAnalyticsPage as t, DismissOptimisationSuggestionDocument as u };