@burdenoff/fluidgrids-fe-sdk 2026.1031.6 → 2026.1101.1

package/dist/{chunk-RYUSWVIR.js → chunk-3M36XWAH.js}

@@ -1,14 +1,19 @@
-import { FailureTriagePanel } from './chunk-NLRQSHRS.js';
-import { useDataSinks, useDataSinkData, useInsightsData, useRunReplayActions } from './chunk-PP62ABIG.js';
-import { useFluidGridsPermission, FLUIDGRIDS_PERMISSIONS } from './chunk-ZUVFD5KV.js';
+import { FailureTriagePanel } from './chunk-ALFMJSD6.js';
+import { useDataSinks, useDataSinkData, useInsightsData, useRunReplayActions } from './chunk-RIHYPPMQ.js';
+import { proposalCanvasPath } from './chunk-GLYINMOR.js';
+import { useContinuousOptimisationEnabled, throwIfResultError } from './chunk-6ILIBJFH.js';
+import { useFluidGridsPermission, FLUIDGRIDS_PERMISSIONS, SdkPermissionButton } from './chunk-ZUVFD5KV.js';
+import { SetContinuousOptimisationEnabledDocument, FgRunOptimisationScanDocument, ProposeOptimisationDocument, WorkflowProposalDocument, DismissOptimisationSuggestionDocument, SnoozeOptimisationSuggestionDocument, OptimisationSuggestionsDocument, ContinuousOptimisationSettingsDocument } from './chunk-IHEV5HTD.js';
 import { useTr } from './chunk-UULVIT25.js';
-import { useState, useMemo, useEffect } from 'react';
+import { getFluidGridsClient } from './chunk-NTWG3CJX.js';
+import { useState, useMemo, useEffect, useRef, useCallback } from 'react';
 import { Icon } from '@iconify/react';
 import { Button } from '@burdenoff/fe-libs/button';
-import { Input } from '@burdenoff/fe-libs/ui';
+import { Input, Button as Button$1, Dialog, DialogContent, DialogHeader, DialogTitle, DialogDescription, Label, Textarea, DialogFooter } from '@burdenoff/fe-libs/ui';
 import { jsxs, jsx, Fragment } from 'react/jsx-runtime';
 import { useNavigate } from 'react-router';
 import { toast } from 'sonner';
+import { Lightbulb, Scissors, Timer, ShieldCheck, DatabaseZap, BadgeDollarSign, RotateCcw } from 'lucide-react';
 
 // src/modules/observability/utils.ts
 function percentage(value, total) {
@@ -339,6 +344,999 @@ function DataSinkDashboardPage() {
     ] })
   ] });
 }
+var SUGGESTIONS_PAGE_SIZE = 20;
+function messageOf(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+function suggestionsReadable(settings) {
+  return Boolean(settings?.killSwitchOn && settings.enabled);
+}
+async function fetchSettings() {
+  const result = throwIfResultError(
+    await getFluidGridsClient().query({
+      query: ContinuousOptimisationSettingsDocument,
+      fetchPolicy: "network-only"
+    })
+  );
+  return result.data?.continuousOptimisationSettings ?? null;
+}
+async function fetchOpenSuggestions() {
+  const result = throwIfResultError(
+    await getFluidGridsClient().query({
+      query: OptimisationSuggestionsDocument,
+      variables: {
+        filter: { status: ["OPEN" /* Open */] },
+        limit: SUGGESTIONS_PAGE_SIZE,
+        offset: 0
+      },
+      fetchPolicy: "network-only"
+    })
+  );
+  const list = result.data?.optimisationSuggestions;
+  return { items: list?.items ?? [], total: list?.total ?? 0 };
+}
+function useContinuousOptimisation(active) {
+  const [settings, setSettings] = useState(null);
+  const [suggestions, setSuggestions] = useState(
+    []
+  );
+  const [total, setTotal] = useState(0);
+  const [loading, setLoading] = useState(active);
+  const [busy, setBusy] = useState(false);
+  const [pendingId, setPendingId] = useState(null);
+  const [error, setError] = useState(null);
+  const [lastScan, setLastScan] = useState(null);
+  const loadRef = useRef(0);
+  const refetchRef = useRef(0);
+  const loadSuggestions = useCallback(
+    async (next, load) => {
+      if (!suggestionsReadable(next)) {
+        if (load === loadRef.current) {
+          setSuggestions([]);
+          setTotal(0);
+        }
+        return;
+      }
+      const list = await fetchOpenSuggestions();
+      if (load !== loadRef.current) return;
+      setSuggestions(list.items);
+      setTotal(list.total);
+    },
+    []
+  );
+  const refetch = useCallback(async () => {
+    const load = ++loadRef.current;
+    const refetchToken = ++refetchRef.current;
+    setLoading(true);
+    setError(null);
+    try {
+      const next = await fetchSettings();
+      if (load !== loadRef.current) return;
+      setSettings(next);
+      await loadSuggestions(next, load);
+    } catch (loadError) {
+      if (load === loadRef.current) setError(messageOf(loadError));
+    } finally {
+      if (refetchToken === refetchRef.current) setLoading(false);
+    }
+  }, [loadSuggestions]);
+  useEffect(() => {
+    void refetch();
+    return () => {
+      loadRef.current++;
+    };
+  }, [active, refetch]);
+  const setEnabled = useCallback(
+    async (enabled) => {
+      const load = ++loadRef.current;
+      setBusy(true);
+      setError(null);
+      try {
+        const result = throwIfResultError(
+          await getFluidGridsClient().mutate({
+            mutation: SetContinuousOptimisationEnabledDocument,
+            variables: { enabled }
+          })
+        );
+        const next = result.data?.setContinuousOptimisationEnabled ?? null;
+        if (load !== loadRef.current) return;
+        setSettings(next);
+        await loadSuggestions(next, load);
+      } catch (toggleError) {
+        if (load === loadRef.current) setError(messageOf(toggleError));
+      } finally {
+        setBusy(false);
+      }
+    },
+    [loadSuggestions]
+  );
+  const runNow = useCallback(async () => {
+    const load = ++loadRef.current;
+    setBusy(true);
+    setError(null);
+    try {
+      const result = throwIfResultError(
+        await getFluidGridsClient().mutate({ mutation: FgRunOptimisationScanDocument })
+      );
+      if (load !== loadRef.current) return;
+      setLastScan(result.data?.fgRunOptimisationScan ?? null);
+      const next = await fetchSettings();
+      if (load !== loadRef.current) return;
+      setSettings(next);
+      await loadSuggestions(next, load);
+    } catch (scanError) {
+      if (load === loadRef.current) setError(messageOf(scanError));
+    } finally {
+      setBusy(false);
+    }
+  }, [loadSuggestions]);
+  const replace = useCallback((updated) => {
+    setSuggestions(
+      (current) => current.map((item) => item.id === updated.id ? updated : item)
+    );
+  }, []);
+  const remove = useCallback((id) => {
+    setSuggestions((current) => current.filter((item) => item.id !== id));
+    setTotal((count) => Math.max(0, count - 1));
+  }, []);
+  const propose = useCallback(
+    async (id) => {
+      setPendingId(id);
+      setError(null);
+      try {
+        const client = getFluidGridsClient();
+        const result = throwIfResultError(
+          await client.mutate({
+            mutation: ProposeOptimisationDocument,
+            variables: { suggestionId: id }
+          })
+        );
+        const updated = result.data?.proposeOptimisation ?? null;
+        if (!updated?.proposalId) return null;
+        replace(updated);
+        const proposal = throwIfResultError(
+          await client.query({
+            query: WorkflowProposalDocument,
+            variables: { id: updated.proposalId },
+            fetchPolicy: "network-only"
+          })
+        ).data?.workflowProposal;
+        return {
+          workflowKey: proposal?.workflowKey || updated.workflowKey,
+          version: proposal?.baseVersion || updated.workflowVersion,
+          proposalId: updated.proposalId
+        };
+      } catch (proposeError) {
+        setError(messageOf(proposeError));
+        return null;
+      } finally {
+        setPendingId(null);
+      }
+    },
+    [replace]
+  );
+  const dismiss = useCallback(
+    async (id, reason, note) => {
+      setPendingId(id);
+      setError(null);
+      const trimmed = note?.trim();
+      try {
+        throwIfResultError(
+          await getFluidGridsClient().mutate({
+            mutation: DismissOptimisationSuggestionDocument,
+            variables: { id, reason, ...trimmed ? { note: trimmed } : {} }
+          })
+        );
+        remove(id);
+        return true;
+      } catch (dismissError) {
+        setError(messageOf(dismissError));
+        return false;
+      } finally {
+        setPendingId(null);
+      }
+    },
+    [remove]
+  );
+  const snooze = useCallback(
+    async (id) => {
+      setPendingId(id);
+      setError(null);
+      try {
+        throwIfResultError(
+          await getFluidGridsClient().mutate({
+            mutation: SnoozeOptimisationSuggestionDocument,
+            variables: { id }
+          })
+        );
+        remove(id);
+        return true;
+      } catch (snoozeError) {
+        setError(messageOf(snoozeError));
+        return false;
+      } finally {
+        setPendingId(null);
+      }
+    },
+    [remove]
+  );
+  return {
+    settings,
+    suggestions,
+    total,
+    loading,
+    busy,
+    pendingId,
+    error,
+    lastScan,
+    refetch,
+    setEnabled,
+    runNow,
+    propose,
+    dismiss,
+    snooze
+  };
+}
+
+// src/modules/observability/optimisation.ts
+var DEFAULT_WINDOW_DAYS = 30;
+var DISMISS_REASONS = [
+  "NOT_APPLICABLE" /* NotApplicable */,
+  "ACCEPTED_COST" /* AcceptedCost */,
+  "WILL_FIX_LATER" /* WillFixLater */,
+  "OTHER" /* Other */
+];
+var MAX_DISMISS_NOTE_LENGTH = 500;
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function evidenceRecord(evidence) {
+  if (typeof evidence === "string") {
+    try {
+      const parsed = JSON.parse(evidence);
+      return isRecord(parsed) ? parsed : {};
+    } catch {
+      return {};
+    }
+  }
+  return isRecord(evidence) ? evidence : {};
+}
+function numberAt(evidence, key) {
+  const value = evidence[key];
+  return typeof value === "number" && Number.isFinite(value) ? value : null;
+}
+function formatShare(value) {
+  return `${Math.round(value * 100)}%`;
+}
+function formatSeconds(ms) {
+  const seconds = ms / 1e3;
+  return `${Number.isInteger(seconds) ? seconds : seconds.toFixed(1)} s`;
+}
+function formatCount(value) {
+  return Math.round(value).toLocaleString("en-US");
+}
+function formatMicroUsd(value) {
+  const dollars = value / 1e6;
+  if (dollars > 0 && dollars < 0.01) return "< $0.01";
+  return `$${dollars.toLocaleString("en-US", {
+    minimumFractionDigits: 2,
+    maximumFractionDigits: 2
+  })}`;
+}
+function monthlySavingLabel(microUsd) {
+  if (microUsd === null || microUsd === void 0) return null;
+  if (!Number.isFinite(microUsd) || microUsd <= 0) return null;
+  return formatMicroUsd(microUsd);
+}
+function evidenceWindowDays(evidence) {
+  const days = numberAt(evidenceRecord(evidence), "windowDays");
+  return days !== null && days > 0 ? days : DEFAULT_WINDOW_DAYS;
+}
+var FACTS = {
+  ["RAISE_TIMEOUT" /* RaiseTimeout */]: [
+    { id: "executions", format: formatCount },
+    { id: "timeoutRate", format: formatShare },
+    { id: "currentTimeoutMs", format: formatSeconds },
+    {
+      id: "p95CompletedMs",
+      format: formatSeconds
+    },
+    {
+      id: "suggestedTimeoutMs",
+      format: formatSeconds
+    }
+  ],
+  ["ADD_RETRY" /* AddRetry */]: [
+    { id: "executions", format: formatCount },
+    {
+      id: "transientFailures",
+      format: formatCount
+    },
+    {
+      id: "transientFailureRate",
+      format: formatShare
+    }
+  ],
+  ["UNUSED_NODE" /* UnusedNode */]: [{ id: "completedRuns", format: formatCount }],
+  ["ENABLE_CACHE" /* EnableCache */]: [
+    { id: "calls", format: formatCount },
+    { id: "repeatedCalls", format: formatCount },
+    { id: "repeatShare", format: formatShare },
+    { id: "costMicroUsd", format: formatMicroUsd }
+  ],
+  ["CHEAPER_MODEL" /* CheaperModel */]: [],
+  ["MISSING_GUARDRAIL" /* MissingGuardrail */]: []
+};
+function evidenceFacts(kind, evidence) {
+  const record = evidenceRecord(evidence);
+  const facts = [];
+  for (const spec of FACTS[kind] ?? []) {
+    const value = numberAt(record, spec.id);
+    if (value === null) continue;
+    facts.push({ id: spec.id, value: spec.format(value) });
+  }
+  if (kind === "UNUSED_NODE" /* UnusedNode */) {
+    const removed = record.removedNodeIds;
+    if (Array.isArray(removed) && removed.length > 0) {
+      facts.push({
+        id: "removedNodeIds",
+        value: removed.map(String).join(", ")
+      });
+    }
+  }
+  if (kind === "ADD_RETRY" /* AddRetry */) {
+    const byType = record.failuresByType;
+    if (isRecord(byType)) {
+      const parts = Object.entries(byType).filter(
+        (entry) => typeof entry[1] === "number" && entry[1] > 0
+      ).map(([type, count]) => `${type} ${formatCount(count)}`);
+      if (parts.length > 0) {
+        facts.push({
+          id: "failuresByType",
+          value: parts.join(", ")
+        });
+      }
+    }
+  }
+  return facts;
+}
+function shortRunId(runId) {
+  return runId.length > 8 ? runId.slice(0, 8) : runId;
+}
+
+// src/modules/observability/optimisation-labels.ts
+function kindLabel(tr, kind) {
+  switch (kind) {
+    case "ADD_RETRY" /* AddRetry */:
+      return tr(
+        "fluidgrids.optimisation.kind.ADD_RETRY",
+        "Retry transient failures"
+      );
+    case "CHEAPER_MODEL" /* CheaperModel */:
+      return tr(
+        "fluidgrids.optimisation.kind.CHEAPER_MODEL",
+        "Use a cheaper model"
+      );
+    case "ENABLE_CACHE" /* EnableCache */:
+      return tr(
+        "fluidgrids.optimisation.kind.ENABLE_CACHE",
+        "Cache repeated model calls"
+      );
+    case "MISSING_GUARDRAIL" /* MissingGuardrail */:
+      return tr(
+        "fluidgrids.optimisation.kind.MISSING_GUARDRAIL",
+        "Add a guardrail policy"
+      );
+    case "RAISE_TIMEOUT" /* RaiseTimeout */:
+      return tr(
+        "fluidgrids.optimisation.kind.RAISE_TIMEOUT",
+        "Raise the node timeout"
+      );
+    case "UNUSED_NODE" /* UnusedNode */:
+      return tr(
+        "fluidgrids.optimisation.kind.UNUSED_NODE",
+        "Remove nodes that never run"
+      );
+  }
+}
+function evidenceLabel(tr, id) {
+  switch (id) {
+    case "executions":
+      return tr("fluidgrids.optimisation.evidence.executions", "Executions");
+    case "timeoutRate":
+      return tr("fluidgrids.optimisation.evidence.timeoutRate", "Timed out");
+    case "currentTimeoutMs":
+      return tr(
+        "fluidgrids.optimisation.evidence.currentTimeoutMs",
+        "Current timeout"
+      );
+    case "p95CompletedMs":
+      return tr(
+        "fluidgrids.optimisation.evidence.p95CompletedMs",
+        "p95 when it finishes"
+      );
+    case "suggestedTimeoutMs":
+      return tr(
+        "fluidgrids.optimisation.evidence.suggestedTimeoutMs",
+        "Suggested timeout"
+      );
+    case "transientFailures":
+      return tr(
+        "fluidgrids.optimisation.evidence.transientFailures",
+        "Temporary failures"
+      );
+    case "transientFailureRate":
+      return tr(
+        "fluidgrids.optimisation.evidence.transientFailureRate",
+        "Failure rate"
+      );
+    case "failuresByType":
+      return tr(
+        "fluidgrids.optimisation.evidence.failuresByType",
+        "By error type"
+      );
+    case "completedRuns":
+      return tr(
+        "fluidgrids.optimisation.evidence.completedRuns",
+        "Completed runs"
+      );
+    case "removedNodeIds":
+      return tr(
+        "fluidgrids.optimisation.evidence.removedNodeIds",
+        "Nodes removed"
+      );
+    case "calls":
+      return tr("fluidgrids.optimisation.evidence.calls", "Model calls");
+    case "repeatedCalls":
+      return tr(
+        "fluidgrids.optimisation.evidence.repeatedCalls",
+        "Repeated calls"
+      );
+    case "repeatShare":
+      return tr("fluidgrids.optimisation.evidence.repeatShare", "Repeated");
+    case "costMicroUsd":
+      return tr("fluidgrids.optimisation.evidence.costMicroUsd", "Model spend");
+  }
+}
+function dismissReasonLabel(tr, reason) {
+  switch (reason) {
+    case "NOT_APPLICABLE" /* NotApplicable */:
+      return tr(
+        "fluidgrids.optimisation.dismissReasons.NOT_APPLICABLE",
+        "Not applicable to this workflow"
+      );
+    case "ACCEPTED_COST" /* AcceptedCost */:
+      return tr(
+        "fluidgrids.optimisation.dismissReasons.ACCEPTED_COST",
+        "The cost is accepted"
+      );
+    case "WILL_FIX_LATER" /* WillFixLater */:
+      return tr(
+        "fluidgrids.optimisation.dismissReasons.WILL_FIX_LATER",
+        "Will fix it later"
+      );
+    case "OTHER" /* Other */:
+      return tr("fluidgrids.optimisation.dismissReasons.OTHER", "Other reason");
+  }
+}
+var KIND_ICONS = {
+  ["ADD_RETRY" /* AddRetry */]: RotateCcw,
+  ["CHEAPER_MODEL" /* CheaperModel */]: BadgeDollarSign,
+  ["ENABLE_CACHE" /* EnableCache */]: DatabaseZap,
+  ["MISSING_GUARDRAIL" /* MissingGuardrail */]: ShieldCheck,
+  ["RAISE_TIMEOUT" /* RaiseTimeout */]: Timer,
+  ["UNUSED_NODE" /* UnusedNode */]: Scissors
+};
+var MAX_RUN_LINKS = 3;
+function OptimisationSuggestionsPanel(props) {
+  const enabled = useContinuousOptimisationEnabled();
+  if (!enabled) return null;
+  return /* @__PURE__ */ jsx(OptimisationSuggestionsSection, { ...props });
+}
+function OptimisationSuggestionsSection({
+  onOpenRun,
+  onOpenProposal
+}) {
+  const tr = useTr();
+  const optimisation = useContinuousOptimisation(true);
+  const { settings } = optimisation;
+  const enabled = settings?.enabled ?? false;
+  const paused = settings !== null && !settings.killSwitchOn;
+  const [dismissing, setDismissing] = useState(null);
+  const apply = async (suggestion) => {
+    const target = await optimisation.propose(suggestion.id);
+    if (target) onOpenProposal(target);
+  };
+  return /* @__PURE__ */ jsxs(
+    "section",
+    {
+      className: "mb-6 rounded-xl border border-border-secondary bg-background-secondary p-4",
+      "data-testid": "optimisation-panel",
+      children: [
+        /* @__PURE__ */ jsxs("div", { className: "flex flex-col gap-3 sm:flex-row sm:items-start sm:justify-between", children: [
+          /* @__PURE__ */ jsx(
+            PanelHeading,
+            {
+              enabled,
+              paused,
+              lastScanAt: settings?.lastScanAt ?? null,
+              tr
+            }
+          ),
+          /* @__PURE__ */ jsx(
+            ManageActions,
+            {
+              optimisation,
+              enabled,
+              paused,
+              tr
+            }
+          )
+        ] }),
+        /* @__PURE__ */ jsx(ReadOnlyNote, { tr }),
+        optimisation.error && /* @__PURE__ */ jsx(
+          "p",
+          {
+            className: "mt-3 text-sm text-status-error-text",
+            role: "alert",
+            "data-testid": "optimisation-error",
+            children: optimisation.error
+          }
+        ),
+        optimisation.lastScan && /* @__PURE__ */ jsx(ScanSummary, { scan: optimisation.lastScan, tr }),
+        optimisation.suggestions.length > 0 ? /* @__PURE__ */ jsxs(Fragment, { children: [
+          /* @__PURE__ */ jsx("ul", { className: "mt-4 space-y-2", "data-testid": "optimisation-list", children: optimisation.suggestions.map((suggestion) => /* @__PURE__ */ jsx(
+            OptimisationSuggestionRow,
+            {
+              suggestion,
+              pending: optimisation.pendingId === suggestion.id,
+              onOpenRun,
+              onApply: () => void apply(suggestion),
+              onSnooze: () => void optimisation.snooze(suggestion.id),
+              onDismiss: () => setDismissing(suggestion),
+              tr
+            },
+            suggestion.id
+          )) }),
+          optimisation.total > optimisation.suggestions.length && /* @__PURE__ */ jsx(
+            "p",
+            {
+              className: "mt-2 text-xs text-text-secondary",
+              "data-testid": "optimisation-more",
+              children: tr(
+                "fluidgrids.optimisation.showingTop",
+                "Showing the best {{shown}} of {{total}} open suggestions.",
+                {
+                  shown: optimisation.suggestions.length,
+                  total: optimisation.total
+                }
+              )
+            }
+          )
+        ] }) : !optimisation.loading && /* @__PURE__ */ jsx(EmptyState, { enabled, paused, tr }),
+        /* @__PURE__ */ jsx(
+          DismissDialog,
+          {
+            suggestion: dismissing,
+            pending: dismissing !== null && optimisation.pendingId === dismissing.id,
+            onClose: () => setDismissing(null),
+            onConfirm: async (reason, note) => {
+              if (!dismissing) return;
+              const done = await optimisation.dismiss(dismissing.id, reason, note);
+              if (done) setDismissing(null);
+            },
+            tr
+          },
+          dismissing?.id ?? "none"
+        )
+      ]
+    }
+  );
+}
+function PanelHeading({
+  enabled,
+  paused,
+  lastScanAt,
+  tr
+}) {
+  const parts = [
+    enabled ? tr("fluidgrids.optimisation.on", "On") : tr("fluidgrids.optimisation.off", "Off")
+  ];
+  if (lastScanAt) {
+    parts.push(
+      tr("fluidgrids.optimisation.lastScan", "last checked {{when}}", {
+        when: new Date(lastScanAt).toLocaleString()
+      })
+    );
+  }
+  if (paused) {
+    parts.push(
+      tr("fluidgrids.optimisation.paused", "paused for this workspace")
+    );
+  }
+  return /* @__PURE__ */ jsxs("div", { className: "min-w-0", children: [
+    /* @__PURE__ */ jsxs("h2", { className: "flex items-center gap-2 text-base font-semibold text-text-primary", children: [
+      /* @__PURE__ */ jsx(Lightbulb, { className: "size-[18px]" }),
+      tr("fluidgrids.optimisation.title", "Suggestions")
+    ] }),
+    /* @__PURE__ */ jsx("p", { className: "mt-1 max-w-2xl text-sm text-text-secondary", children: tr(
+      "fluidgrids.optimisation.description",
+      "Every night, reads the last 30 days of production runs and model calls and suggests changes that save money or avoid failures. Applying one opens a proposal on the canvas for you to review; nothing changes on its own."
+    ) }),
+    /* @__PURE__ */ jsx(
+      "p",
+      {
+        className: "mt-1 text-xs text-text-secondary",
+        "data-testid": "optimisation-status",
+        children: parts.join(" \xB7 ")
+      }
+    )
+  ] });
+}
+function ReadOnlyNote({ tr }) {
+  const { allowed: canManage } = useFluidGridsPermission(
+    FLUIDGRIDS_PERMISSIONS.WORKFLOW_PUBLISH
+  );
+  const { allowed: canApply } = useFluidGridsPermission(
+    FLUIDGRIDS_PERMISSIONS.AI_WORKFLOW_CREATE
+  );
+  const { allowed: canUpdate, isLoading } = useFluidGridsPermission(
+    FLUIDGRIDS_PERMISSIONS.WORKFLOW_UPDATE
+  );
+  if (isLoading || canManage || canApply || canUpdate) return null;
+  return /* @__PURE__ */ jsx(
+    "p",
+    {
+      className: "mt-3 text-xs text-text-secondary",
+      "data-testid": "optimisation-read-only",
+      children: tr(
+        "fluidgrids.optimisation.readOnly",
+        "You can view suggestions. Applying, dismissing or changing them needs edit access to workflows."
+      )
+    }
+  );
+}
+function ScanSummary({
+  scan,
+  tr
+}) {
+  return /* @__PURE__ */ jsx(
+    "p",
+    {
+      className: "mt-3 text-xs text-text-secondary",
+      "data-testid": "optimisation-last-scan",
+      children: scan.skipped ? tr(
+        "fluidgrids.optimisation.scanSkipped",
+        "The check was skipped: continuous optimisation is off for this workspace."
+      ) : tr(
+        "fluidgrids.optimisation.scanSummary",
+        "Checked {{workflows}} workflow(s): {{created}} new, {{resolved}} no longer needed, {{open}} open.",
+        {
+          workflows: scan.workflowsScanned,
+          created: scan.created,
+          resolved: scan.resolved,
+          open: scan.openSuggestions
+        }
+      )
+    }
+  );
+}
+function EmptyState({
+  enabled,
+  paused,
+  tr
+}) {
+  let message = tr(
+    "fluidgrids.optimisation.emptyOff",
+    "Turn continuous optimisation on to get nightly suggestions for your workflows here."
+  );
+  if (paused) {
+    message = tr(
+      "fluidgrids.optimisation.emptyPaused",
+      "Continuous optimisation is paused for this workspace."
+    );
+  } else if (enabled) {
+    message = tr(
+      "fluidgrids.optimisation.empty",
+      "No suggestions right now. New ones appear here the morning after a check finds something."
+    );
+  }
+  return /* @__PURE__ */ jsx(
+    "p",
+    {
+      className: "mt-4 text-sm text-text-secondary",
+      "data-testid": "optimisation-empty",
+      children: message
+    }
+  );
+}
+function ManageActions({
+  optimisation,
+  enabled,
+  paused,
+  tr
+}) {
+  const denied = tr(
+    "fluidgrids.optimisation.manageDenied",
+    "You need permission to publish workflows to change this"
+  );
+  return /* @__PURE__ */ jsxs("div", { className: "flex shrink-0 flex-wrap gap-2", children: [
+    enabled && !paused && /* @__PURE__ */ jsx(
+      SdkPermissionButton,
+      {
+        permission: FLUIDGRIDS_PERMISSIONS.WORKFLOW_PUBLISH,
+        deniedTooltip: denied,
+        children: /* @__PURE__ */ jsx(
+          Button$1,
+          {
+            size: "sm",
+            variant: "outline",
+            onClick: () => void optimisation.runNow(),
+            disabled: optimisation.busy,
+            "data-testid": "optimisation-run-now",
+            children: tr("fluidgrids.optimisation.runNow", "Check now")
+          }
+        )
+      }
+    ),
+    /* @__PURE__ */ jsx(
+      SdkPermissionButton,
+      {
+        permission: FLUIDGRIDS_PERMISSIONS.WORKFLOW_PUBLISH,
+        deniedTooltip: denied,
+        children: /* @__PURE__ */ jsx(
+          Button$1,
+          {
+            size: "sm",
+            variant: enabled ? "outline" : "default",
+            onClick: () => void optimisation.setEnabled(!enabled),
+            disabled: optimisation.busy || optimisation.loading || optimisation.settings === null || paused && !enabled,
+            "data-testid": "optimisation-toggle",
+            children: enabled ? tr("fluidgrids.optimisation.turnOff", "Turn off") : tr("fluidgrids.optimisation.turnOn", "Turn on")
+          }
+        )
+      }
+    )
+  ] });
+}
+function OptimisationSuggestionRow({
+  suggestion,
+  pending,
+  onOpenRun,
+  onApply,
+  onSnooze,
+  onDismiss,
+  tr
+}) {
+  const kind = suggestion.kind;
+  const KindIcon = KIND_ICONS[kind] ?? Lightbulb;
+  const facts = evidenceFacts(kind, suggestion.evidence);
+  const saving = monthlySavingLabel(suggestion.estimatedMonthlySavingMicroUsd);
+  const runs = suggestion.sampleRunIds.slice(0, MAX_RUN_LINKS);
+  const updateDenied = tr(
+    "fluidgrids.optimisation.updateDenied",
+    "You need edit access to workflows to change suggestions"
+  );
+  return /* @__PURE__ */ jsx(
+    "li",
+    {
+      className: "rounded-lg border border-border-secondary bg-background-primary p-3",
+      "data-testid": "optimisation-suggestion",
+      "data-kind": String(kind),
+      children: /* @__PURE__ */ jsxs("div", { className: "flex flex-col gap-3 lg:flex-row lg:items-start lg:justify-between", children: [
+        /* @__PURE__ */ jsxs("div", { className: "min-w-0 flex-1", children: [
+          /* @__PURE__ */ jsxs("div", { className: "flex flex-wrap items-center gap-2 text-sm", children: [
+            /* @__PURE__ */ jsxs("span", { className: "inline-flex items-center gap-1 rounded-full bg-background-secondary px-2 py-0.5 text-xs text-text-secondary", children: [
+              /* @__PURE__ */ jsx(KindIcon, { className: "size-3.5" }),
+              kindLabel(tr, kind)
+            ] }),
+            /* @__PURE__ */ jsx("span", { className: "font-medium text-text-primary", children: suggestion.workflowName || suggestion.workflowKey }),
+            /* @__PURE__ */ jsx("span", { className: "text-text-secondary", children: tr("fluidgrids.optimisation.atNode", "at {{node}}", {
+              node: suggestion.nodeId
+            }) }),
+            saving && /* @__PURE__ */ jsx(
+              "span",
+              {
+                className: "inline-flex items-center rounded-full border border-status-success-border bg-status-success-bg-subtle px-2 py-0.5 text-xs text-status-success-text",
+                "data-testid": "optimisation-saving",
+                children: tr(
+                  "fluidgrids.optimisation.saving",
+                  "Saves about {{amount}} a month",
+                  { amount: saving }
+                )
+              }
+            )
+          ] }),
+          /* @__PURE__ */ jsx("p", { className: "mt-1 break-words text-sm text-text-primary", children: suggestion.advice }),
+          facts.length > 0 && /* @__PURE__ */ jsx(
+            "dl",
+            {
+              className: "mt-2 flex flex-wrap gap-x-4 gap-y-1 text-xs",
+              "data-testid": "optimisation-evidence",
+              children: facts.map((fact) => /* @__PURE__ */ jsxs("div", { className: "flex gap-1", children: [
+                /* @__PURE__ */ jsx("dt", { className: "text-text-secondary", children: evidenceLabel(tr, fact.id) }),
+                /* @__PURE__ */ jsx("dd", { className: "font-medium text-text-primary", children: fact.value })
+              ] }, fact.id))
+            }
+          ),
+          /* @__PURE__ */ jsxs("p", { className: "mt-1 text-xs text-text-secondary", children: [
+            tr(
+              "fluidgrids.optimisation.window",
+              "Last {{days}} days \xB7 first seen {{when}}",
+              {
+                days: evidenceWindowDays(suggestion.evidence),
+                when: new Date(
+                  String(suggestion.firstSeenAt)
+                ).toLocaleDateString()
+              }
+            ),
+            runs.length > 0 && ` \xB7 ${tr("fluidgrids.optimisation.runs", "runs")} `,
+            runs.map((runId, index) => /* @__PURE__ */ jsxs("span", { children: [
+              index > 0 && ", ",
+              /* @__PURE__ */ jsx(
+                "button",
+                {
+                  type: "button",
+                  className: "text-text-link underline-offset-2 hover:underline",
+                  onClick: () => onOpenRun(runId),
+                  "data-testid": "optimisation-run-link",
+                  children: shortRunId(runId)
+                }
+              )
+            ] }, runId))
+          ] }),
+          !suggestion.applicable && suggestion.applyBlockedReason && /* @__PURE__ */ jsx(
+            "p",
+            {
+              className: "mt-2 text-xs text-status-warning-text",
+              "data-testid": "optimisation-apply-blocked",
+              children: suggestion.applyBlockedReason
+            }
+          )
+        ] }),
+        /* @__PURE__ */ jsxs("div", { className: "flex shrink-0 flex-wrap gap-2", children: [
+          /* @__PURE__ */ jsx(
+            SdkPermissionButton,
+            {
+              permission: FLUIDGRIDS_PERMISSIONS.AI_WORKFLOW_CREATE,
+              deniedTooltip: tr(
+                "fluidgrids.optimisation.applyDenied",
+                "You need permission to create AI workflow proposals to apply suggestions"
+              ),
+              children: /* @__PURE__ */ jsx(
+                Button$1,
+                {
+                  size: "sm",
+                  onClick: onApply,
+                  disabled: pending || !suggestion.applicable,
+                  title: suggestion.applicable ? void 0 : suggestion.applyBlockedReason ?? void 0,
+                  "data-testid": "optimisation-apply",
+                  children: tr("fluidgrids.optimisation.apply", "Apply")
+                }
+              )
+            }
+          ),
+          /* @__PURE__ */ jsx(
+            SdkPermissionButton,
+            {
+              permission: FLUIDGRIDS_PERMISSIONS.WORKFLOW_UPDATE,
+              deniedTooltip: updateDenied,
+              children: /* @__PURE__ */ jsx(
+                Button$1,
+                {
+                  size: "sm",
+                  variant: "outline",
+                  onClick: onSnooze,
+                  disabled: pending,
+                  "data-testid": "optimisation-snooze",
+                  children: tr("fluidgrids.optimisation.snooze", "Snooze 30 days")
+                }
+              )
+            }
+          ),
+          /* @__PURE__ */ jsx(
+            SdkPermissionButton,
+            {
+              permission: FLUIDGRIDS_PERMISSIONS.WORKFLOW_UPDATE,
+              deniedTooltip: updateDenied,
+              children: /* @__PURE__ */ jsx(
+                Button$1,
+                {
+                  size: "sm",
+                  variant: "ghost",
+                  onClick: onDismiss,
+                  disabled: pending,
+                  "data-testid": "optimisation-dismiss",
+                  children: tr("fluidgrids.optimisation.dismiss", "Dismiss")
+                }
+              )
+            }
+          )
+        ] })
+      ] })
+    }
+  );
+}
+function DismissDialog({
+  suggestion,
+  pending,
+  onClose,
+  onConfirm,
+  tr
+}) {
+  const [reason, setReason] = useState(
+    "NOT_APPLICABLE" /* NotApplicable */
+  );
+  const [note, setNote] = useState("");
+  return /* @__PURE__ */ jsx(
+    Dialog,
+    {
+      open: suggestion !== null,
+      onOpenChange: (open) => {
+        if (!open) onClose();
+      },
+      children: /* @__PURE__ */ jsxs(DialogContent, { "data-testid": "optimisation-dismiss-dialog", children: [
+        /* @__PURE__ */ jsxs(DialogHeader, { children: [
+          /* @__PURE__ */ jsx(DialogTitle, { children: tr("fluidgrids.optimisation.dismissTitle", "Dismiss suggestion") }),
+          /* @__PURE__ */ jsx(DialogDescription, { children: tr(
+            "fluidgrids.optimisation.dismissDescription",
+            "Tell us why. Suggestions marked not applicable rank lower for this workspace from now on. A dismissed suggestion comes back only if its evidence at least doubles."
+          ) })
+        ] }),
+        /* @__PURE__ */ jsxs("fieldset", { className: "flex flex-col gap-2", children: [
+          /* @__PURE__ */ jsx("legend", { className: "sr-only", children: tr("fluidgrids.optimisation.dismissReason", "Reason") }),
+          DISMISS_REASONS.map((option) => /* @__PURE__ */ jsxs(
+            "label",
+            {
+              className: "flex cursor-pointer items-center gap-2 text-sm text-text-primary",
+              children: [
+                /* @__PURE__ */ jsx(
+                  "input",
+                  {
+                    type: "radio",
+                    name: "optimisation-dismiss-reason",
+                    value: option,
+                    checked: reason === option,
+                    onChange: () => setReason(option),
+                    "data-testid": `optimisation-dismiss-reason-${option}`
+                  }
+                ),
+                dismissReasonLabel(tr, option)
+              ]
+            },
+            option
+          ))
+        ] }),
+        /* @__PURE__ */ jsxs("div", { className: "flex flex-col gap-1.5", children: [
+          /* @__PURE__ */ jsx(Label, { htmlFor: "optimisation-dismiss-note", children: tr("fluidgrids.optimisation.dismissNote", "Note (optional)") }),
+          /* @__PURE__ */ jsx(
+            Textarea,
+            {
+              id: "optimisation-dismiss-note",
+              "data-testid": "optimisation-dismiss-note",
+              rows: 3,
+              maxLength: MAX_DISMISS_NOTE_LENGTH,
+              value: note,
+              onChange: (event) => setNote(event.target.value)
+            }
+          )
+        ] }),
+        /* @__PURE__ */ jsxs(DialogFooter, { children: [
+          /* @__PURE__ */ jsx(Button$1, { variant: "outline", onClick: onClose, disabled: pending, children: tr("fluidgrids.optimisation.cancel", "Cancel") }),
+          /* @__PURE__ */ jsx(
+            Button$1,
+            {
+              onClick: () => void onConfirm(reason, note),
+              disabled: pending,
+              "data-testid": "optimisation-dismiss-confirm",
+              children: tr("fluidgrids.optimisation.dismissConfirm", "Dismiss")
+            }
+          )
+        ] })
+      ] })
+    }
+  );
+}
 function normalizedRate(summary) {
   const supplied = summary.workflowSuccessRate;
   if (supplied !== null && supplied !== void 0) {
@@ -516,6 +1514,17 @@ function InsightsPage({ showErrors = false }) {
         }
       }
     ),
+    activeTab === "overview" && // Continuous optimisation (BOFF-9969): renders only with the
+    // fluidgrids.continuous-optimisation flag on.
+    /* @__PURE__ */ jsx(
+      OptimisationSuggestionsPanel,
+      {
+        onOpenRun: (runId) => navigate(`../runs/${runId}`),
+        onOpenProposal: (target) => navigate(
+          `../${proposalCanvasPath(target.workflowKey, target.version, target.proposalId)}`
+        )
+      }
+    ),
     loading && !summary ? /* @__PURE__ */ jsx(LoadingState, {}) : activeTab === "overview" && summary ? /* @__PURE__ */ jsx(
       OverviewContent,
       {