diff --git a/schema.graphql b/schema.graphql
index bce38d49..b50491cf 100644
--- a/schema.graphql
+++ b/schema.graphql
@@ -69,6 +69,7 @@ type AssignedItemCount {
 enum AssignmentItemType {
   TICKET
   KNOWLEDGE_ARTICLE
+  INSIGHT
 }
 
 enum AssignmentTargetType {
@@ -1894,6 +1895,17 @@ type Query {
     a list of insights must not be able to pull notes row by row.
     """
     insightNotes(insightId: ID!, first: Int, after: String): InsightNoteConnection!
+    """
+    A ready-to-send chat message about one insight: a short ask plus the `@insight:<id>` marker the
+    assistant expands into the finding itself. Built server-side so the marker carries the stored id,
+    which the client never sees, and the text cannot go stale when the detector refreshes the insight.
+    """
+    insightChatPrompt(id: ID!): String!
+    """
+    Which status an insight may move to from each status it can be in. The mutations below enforce
+    exactly this table, so a client can drive its controls from it rather than restating the rules.
+    """
+    insightStatusTransitions: [InsightStatusTransition!]!
 
   """ Relay Node interface queries"""
   node(id: ID!): Node
@@ -3467,6 +3479,13 @@ input SnoozeInsightInput {
     until: Instant!
 }
 
+type InsightStatusTransition {
+    "The status an insight is in."
+    from: InsightStatus!
+    "Every status it may move to from there."
+    to: [InsightStatus!]!
+}
+
 type InsightConnection {
     edges: [InsightEdge!]!
     pageInfo: PageInfo!
diff --git a/src/app/(app)/incidents/components/incident-assigned-tickets.tsx b/src/app/(app)/incidents/components/incident-assigned-tickets.tsx
new file mode 100644
index 00000000..9f7d006c
--- /dev/null
+++ b/src/app/(app)/incidents/components/incident-assigned-tickets.tsx
@@ -0,0 +1,21 @@
+'use client';
+
+import { AssignedItemsView, useAssignedItems } from '@/components/assignments';
+
+/**
+ * "Assigned Ticket": the tickets filed from this incident. The server records
+ * the link as an assignment owned by the insight (item INSIGHT → target TICKET)
+ * when a ticket is created with `insightId`, so this is the ticket page's
+ * Assigned Items view pointed at the incident. Nothing while loading or empty —
+ * a section that appears with its rows, not a slot the page reserves.
+ */
+export function IncidentAssignedTickets({ incidentId }: { incidentId: string }) {
+  const { tickets } = useAssignedItems({ itemId: incidentId, itemType: 'INSIGHT' });
+  if (!tickets?.length) return null;
+  return (
+    <section className="flex flex-col gap-[var(--spacing-system-m)]">
+      <h2 className="text-ods-text-primary text-h2">Assigned Ticket</h2>
+      <AssignedItemsView itemId={incidentId} itemType="INSIGHT" showTitle={false} />
+    </section>
+  );
+}
diff --git a/src/app/(app)/incidents/components/incident-details-view.tsx b/src/app/(app)/incidents/components/incident-details-view.tsx
index 523dbfa1..06419312 100644
--- a/src/app/(app)/incidents/components/incident-details-view.tsx
+++ b/src/app/(app)/incidents/components/incident-details-view.tsx
@@ -11,14 +11,16 @@ import { InsightStatus } from '@/generated/schema-enums';
 import { routes } from '@/lib/routes';
 import { CONTEXT_ENTITY_KIND } from '../../mingo/context/context-types';
 import { useTrackOpenView } from '../../mingo/context/use-track-open-view';
-import { useMingoLauncherStore } from '../../mingo/stores/mingo-launcher-store';
-import { useIncident } from '../hooks/use-incident';
+import { mingoActionFor, useFixWithMingo } from '../hooks/use-fix-with-mingo';
+import { useIncident, useIncidentDetail } from '../hooks/use-incident';
+import { useLatestIncidentDialog } from '../hooks/use-incident-dialogs';
 import { useIncidentTransitions } from '../hooks/use-incident-transitions';
-import { incidentMingoDraft } from '../utils/fix-with-mingo-prompt';
-import { INCIDENT_TRANSITION_ACTIONS, transitionsFrom } from '../utils/incident-labels';
+import { INCIDENT_TRANSITION_ACTIONS } from '../utils/incident-labels';
+import { transitionsFrom } from '../utils/incident-transform';
+import { IncidentAssignedTickets } from './incident-assigned-tickets';
 import { IncidentAssignee } from './incident-assignee';
 import { IncidentNotes } from './incident-notes';
-import { IncidentQueryResults } from './incident-query-results';
+import { IncidentQueryResults, IncidentQueryResultsSkeleton } from './incident-query-results';
 import { IncidentSummaryCard, IncidentSummaryCardSkeleton } from './incident-summary-card';
 import { SnoozeIncidentModal } from './snooze-incident-modal';
 import { transitionMenuItems } from './transition-menu-items';
@@ -41,36 +43,39 @@ const TICKET_PREFILL_DESCRIPTION_MAX = 1000;
  * what waits for it.
  */
 function IncidentHeader({ incidentId }: IncidentDetailsViewProps) {
-  const incident = useIncident(incidentId);
+  const { incident, transitions } = useIncidentDetail(incidentId);
 
   const handleBack = useSafeBack(routes.incidents.list);
-  const canOpenMingo = useMingoLauncherStore(state => state.canOpen);
+  const mingoControls = useFixWithMingo();
+  // One Mingo button: reopen the chat already started from this incident, or start one.
+  const mingoSession = useLatestIncidentDialog(incident.insightId);
   // Mingo's "open view": this incident rides on every message sent while the page is up.
-  useTrackOpenView({ type: CONTEXT_ENTITY_KIND.INSIGHT, id: incident.id, label: incident.title });
+  useTrackOpenView({ type: CONTEXT_ENTITY_KIND.INSIGHT, id: incident.insightId, label: incident.title });
   const { transition, snoozeTarget, cancelSnooze, confirmSnooze, isMutating, isSnoozing } = useIncidentTransitions();
 
   // The status button is named after the transition the technician most likely
   // wants — Resolve while the incident is open — and its menu lists every legal
   // one (design: "Resolve ▾"). A resolved incident offers Archive / Reopen.
-  const targets = transitionsFrom(incident.status);
+  const targets = transitionsFrom(transitions, incident.status);
   const primary = targets.includes(InsightStatus.RESOLVED) ? InsightStatus.RESOLVED : targets[0];
   // A deleted assignee is not offered by the ticket picker — the ticket starts unassigned.
   const ticketAssignee = incident.assignee && !incident.assignee.deleted ? incident.assignee : undefined;
 
+  const mingoIcon = (
+    <MingoIcon
+      className="size-5"
+      eyesColor="var(--ods-flamingo-cyan-base)"
+      cornerColor="var(--ods-flamingo-cyan-base)"
+    />
+  );
+  const mingoAction: PageActionButton = {
+    ...mingoActionFor(incident, mingoSession, mingoControls),
+    variant: 'outline',
+    icon: mingoIcon,
+  };
+
   const actions: PageActionButton[] = [
-    {
-      label: 'Fix with Mingo',
-      variant: 'outline',
-      icon: (
-        <MingoIcon
-          className="size-5"
-          eyesColor="var(--ods-flamingo-cyan-base)"
-          cornerColor="var(--ods-flamingo-cyan-base)"
-        />
-      ),
-      onClick: () => useMingoLauncherStore.getState().draftToMingo(incidentMingoDraft(incident)),
-      disabled: !canOpenMingo,
-    },
+    mingoAction,
     {
       label: 'Create Ticket',
       variant: 'outline',
@@ -84,6 +89,8 @@ function IncidentHeader({ incidentId }: IncidentDetailsViewProps) {
         deviceName: incident.deviceName,
         assigneeId: ticketAssignee?.id,
         assigneeName: ticketAssignee?.name,
+        insightId: incident.insightId,
+        insightTitle: incident.title,
       }),
     },
     ...(primary
@@ -92,7 +99,7 @@ function IncidentHeader({ incidentId }: IncidentDetailsViewProps) {
             label: INCIDENT_TRANSITION_ACTIONS[primary].label,
             variant: 'outline' as const,
             disabled: isMutating,
-            submenu: transitionMenuItems(incident, transition, isMutating),
+            submenu: transitionMenuItems(incident, transitions, transition, isMutating),
           },
         ]
       : []),
@@ -168,6 +175,7 @@ export function IncidentDetailsSkeleton() {
         <>
           <IncidentSummaryCardSkeleton />
           <NotesSectionSkeleton />
+          <IncidentQueryResultsSkeleton />
         </>
       }
     />
@@ -195,7 +203,8 @@ export const IncidentDetailsView = memo(function IncidentDetailsViewImpl({ incid
             <IncidentSummary incidentId={incidentId} />
           </Suspense>
           <IncidentNotes incidentId={incidentId} />
-          <Suspense fallback={null}>
+          <IncidentAssignedTickets incidentId={incidentId} />
+          <Suspense fallback={<IncidentQueryResultsSkeleton />}>
             <IncidentEvidence incidentId={incidentId} />
           </Suspense>
         </>
diff --git a/src/app/(app)/incidents/components/incident-query-results.tsx b/src/app/(app)/incidents/components/incident-query-results.tsx
index 729dfa13..cbba8789 100644
--- a/src/app/(app)/incidents/components/incident-query-results.tsx
+++ b/src/app/(app)/incidents/components/incident-query-results.tsx
@@ -1,6 +1,7 @@
 'use client';
 
 import { QueryReportTable } from '@flamingo-stack/openframe-frontend-core/components/ui';
+import type { ReactNode } from 'react';
 import type { Incident } from '../utils/incident-transform';
 
 /** The first column of the evidence table: the machine every row came from. */
@@ -17,8 +18,7 @@ export function IncidentQueryResults({ incident }: { incident: Incident }) {
   const rows = (incident.queryResult ?? []).map(row => ({ ...row, [DEVICE_COLUMN]: incident.deviceName }));
 
   return (
-    <section className="flex flex-col gap-[var(--spacing-system-m)]">
-      <h2 className="text-ods-text-primary text-h2">Query Details</h2>
+    <QueryResultsFrame>
       <QueryReportTable
         data={rows}
         columnOrder={[DEVICE_COLUMN]}
@@ -29,6 +29,29 @@ export function IncidentQueryResults({ incident }: { incident: Incident }) {
             : 'Evidence was not kept for this incident.'
         }
       />
+    </QueryResultsFrame>
+  );
+}
+
+/** The section's shell — the heading over the table — shared by the loaded state and its skeleton. */
+function QueryResultsFrame({ children }: { children: ReactNode }) {
+  return (
+    <section className="flex flex-col gap-[var(--spacing-system-m)]">
+      <h2 className="text-ods-text-primary text-h2">Query Details</h2>
+      {children}
     </section>
   );
 }
+
+/**
+ * The same heading over the report table's own loading rows. The column count
+ * is the detecting query's and unknown until the record lands; four is the
+ * common shape (device + three query columns), one row the common count.
+ */
+export function IncidentQueryResultsSkeleton() {
+  return (
+    <QueryResultsFrame>
+      <QueryReportTable data={[]} loading skeletonRows={1} skeletonColumns={4} showExport={false} />
+    </QueryResultsFrame>
+  );
+}
diff --git a/src/app/(app)/incidents/components/incidents-table.tsx b/src/app/(app)/incidents/components/incidents-table.tsx
index 0e1ddf05..400d738a 100644
--- a/src/app/(app)/incidents/components/incidents-table.tsx
+++ b/src/app/(app)/incidents/components/incidents-table.tsx
@@ -45,10 +45,10 @@ import { getRelayErrorMessage } from '@/lib/handle-api-error';
 import { openInNewTab } from '@/lib/open-in-new-tab';
 import { routes } from '@/lib/routes';
 import { multiSelectFilterFn } from '@/lib/table-filters';
-import { useMingoLauncherStore } from '../../mingo/stores/mingo-launcher-store';
 import { type FacetEntry, type FacetOption, facetToSortedOptions } from '../../scripts/shared/utils/facet-options';
+import { type MingoAction, mingoActionFor, useFixWithMingo } from '../hooks/use-fix-with-mingo';
+import { useLatestIncidentDialogs } from '../hooks/use-incident-dialogs';
 import { useIncidentTransitions } from '../hooks/use-incident-transitions';
-import { incidentMingoDraft } from '../utils/fix-with-mingo-prompt';
 import {
   enumMembers,
   INCIDENT_SEVERITY_LABELS,
@@ -57,7 +57,7 @@ import {
   labelOf,
   WORKING_SET_STATUSES,
 } from '../utils/incident-labels';
-import { type IncidentRow, toIncidentRow } from '../utils/incident-transform';
+import { type IncidentRow, toIncidentRow, toTransitionTable } from '../utils/incident-transform';
 import { IncidentSeverityTag, IncidentStatusTag } from './incident-tags';
 import { INCIDENT_COLUMNS, INCIDENTS_TABLE_COLUMNS } from './incidents-table-columns';
 import { SnoozeIncidentModal } from './snooze-incident-modal';
@@ -72,6 +72,17 @@ const PAGE_SIZE = 20;
  */
 type ColumnFilterState = { id: string; value: unknown }[];
 
+/**
+ * A row plus everything its Mingo button draws. It rides IN the row data rather
+ * than in the column defs on purpose: `DataTableRow` is memoized on the row
+ * object, which TanStack keeps stable across column changes, so a cell reading
+ * any value from the columns' closure keeps showing what it saw first. The
+ * `rows` memo below rebuilds on every input of the action.
+ */
+interface IncidentTableRow extends IncidentRow {
+  mingoAction: MingoAction;
+}
+
 /**
  * Dropdown options for an enum facet, labelled with this app's names so the
  * dropdown matches the cells; server order is kept. (The customer facet keeps
@@ -130,7 +141,7 @@ function IncidentsTableContent({
 }: IncidentsTableContentProps) {
   const { toast } = useToast();
   const environment = useRelayEnvironment();
-  const canOpenMingo = useMingoLauncherStore(state => state.canOpen);
+  const mingoControls = useFixWithMingo();
 
   // One round-trip per interaction: the filter facets (`insightFilters`) ride the
   // list operation — see the query docstring for the facet semantics.
@@ -151,8 +162,18 @@ function IncidentsTableContent({
     IncidentsFragmentKey
   >(incidentsTableRelayFragment, queryData);
 
-  const rows: IncidentRow[] = (data.insights?.edges ?? []).flatMap(edge =>
-    edge?.node ? [toIncidentRow(edge.node)] : [],
+  // Manual memos on purpose: TanStack compares `data` by identity, so `rows`
+  // must only change when an input does — and `incidents` is its stable input.
+  const incidents = useMemo<IncidentRow[]>(
+    () => (data.insights?.edges ?? []).flatMap(edge => (edge?.node ? [toIncidentRow(edge.node)] : [])),
+    [data.insights?.edges],
+  );
+  // Which rows already have a chat: their button reopens it instead of starting one.
+  const mingoSessions = useLatestIncidentDialogs(incidents.map(row => row.insightId));
+  const rows = useMemo<IncidentTableRow[]>(
+    () =>
+      incidents.map(row => ({ ...row, mingoAction: mingoActionFor(row, mingoSessions[row.insightId], mingoControls) })),
+    [incidents, mingoSessions, mingoControls],
   );
 
   // A failed page must stop the footer: its sentinel stays in view, Relay
@@ -214,17 +235,18 @@ function IncidentsTableContent({
 
   const { transition, snoozeTarget, cancelSnooze, confirmSnooze, isMutating, isSnoozing } =
     useIncidentTransitions(refreshFilterMeta);
+  const transitionTable = toTransitionTable(queryData);
 
-  const columns = useMemo<ColumnDef<IncidentRow>[]>(() => {
+  const columns = useMemo<ColumnDef<IncidentTableRow>[]>(() => {
     const renderRowActions = (row: IncidentRow) => {
-      const items = transitionMenuItems(row, transition, isMutating);
+      const items = transitionMenuItems(row, transitionTable, transition, isMutating);
       return items.length > 0 ? <ActionsMenuDropdown groups={[{ items }]} /> : null;
     };
     return [
       {
         accessorKey: 'type',
         header: INCIDENT_COLUMNS.incident.header,
-        cell: ({ row }: { row: Row<IncidentRow> }) => (
+        cell: ({ row }: { row: Row<IncidentTableRow> }) => (
           <div className="flex min-w-0 flex-col justify-center gap-[var(--spacing-system-xxs)]">
             <TruncateText>{row.original.title}</TruncateText>
             {/* The Status column is hidden below lg; its time line moves under the title. */}
@@ -249,7 +271,7 @@ function IncidentsTableContent({
         // device facet, and a customer narrows the fleet the way a technician does.
         accessorKey: 'organizationId',
         header: INCIDENT_COLUMNS.device.header,
-        cell: ({ row }: { row: Row<IncidentRow> }) => (
+        cell: ({ row }: { row: Row<IncidentTableRow> }) => (
           <div className="flex min-w-0 flex-col justify-center gap-[var(--spacing-system-xxs)]">
             <div className="flex min-w-0 items-center gap-[var(--spacing-system-xxs)]">
               {renderDeviceTypeIcon(row.original.deviceType ?? undefined, 'size-6 shrink-0 text-ods-text-secondary')}
@@ -271,7 +293,7 @@ function IncidentsTableContent({
       {
         accessorKey: 'severity',
         header: INCIDENT_COLUMNS.severity.header,
-        cell: ({ row }: { row: Row<IncidentRow> }) => <IncidentSeverityTag severity={row.original.severity} />,
+        cell: ({ row }: { row: Row<IncidentTableRow> }) => <IncidentSeverityTag severity={row.original.severity} />,
         enableSorting: false,
         filterFn: multiSelectFilterFn,
         meta: liveColumnMeta(INCIDENT_COLUMNS.severity, { filter: { options: severityOptions } }),
@@ -279,7 +301,7 @@ function IncidentsTableContent({
       {
         accessorKey: 'status',
         header: INCIDENT_COLUMNS.status.header,
-        cell: ({ row }: { row: Row<IncidentRow> }) => (
+        cell: ({ row }: { row: Row<IncidentTableRow> }) => (
           <div className="flex min-w-0 flex-col items-start justify-center gap-[var(--spacing-system-xxs)]">
             <IncidentStatusTag status={row.original.status} />
             <TruncateText variant="h6" tone="secondary">
@@ -297,7 +319,7 @@ function IncidentsTableContent({
       },
       {
         id: 'actions',
-        cell: ({ row }: { row: Row<IncidentRow> }) => (
+        cell: ({ row }: { row: Row<IncidentTableRow> }) => (
           <div data-no-row-click className="pointer-events-auto flex items-center justify-end">
             {renderRowActions(row.original)}
           </div>
@@ -306,35 +328,39 @@ function IncidentsTableContent({
         meta: liveColumnMeta(INCIDENT_COLUMNS.actions),
       },
       {
-        // "Fix with Mingo": opens the drawer on a fresh chat with the incident
-        // prefilled in the composer — nothing sent. Disabled while no drawer is
-        // mounted (locked workspace).
+        // The Mingo button, as `mingoActionFor` decides it (see `IncidentTableRow`
+        // for why the cell reads nothing but the row).
         id: 'mingo',
-        cell: ({ row }: { row: Row<IncidentRow> }) => (
-          <div data-no-row-click className="pointer-events-auto flex items-center justify-end">
-            <Button
-              onClick={() => useMingoLauncherStore.getState().draftToMingo(incidentMingoDraft(row.original))}
-              variant="outline"
-              size="icon"
-              leftIcon={
-                <MingoIcon
-                  className="size-5"
-                  eyesColor="var(--ods-flamingo-cyan-base)"
-                  cornerColor="var(--ods-flamingo-cyan-base)"
-                />
-              }
-              aria-label="Fix with Mingo"
-              disabled={!canOpenMingo}
-              className="bg-ods-card"
-            />
-          </div>
-        ),
+        cell: ({ row }: { row: Row<IncidentTableRow> }) => {
+          const { label, onClick, disabled, loading } = row.original.mingoAction;
+          return (
+            <div data-no-row-click className="pointer-events-auto flex items-center justify-end">
+              <Button
+                onClick={onClick}
+                variant="outline"
+                size="icon"
+                leftIcon={
+                  <MingoIcon
+                    className="size-5"
+                    eyesColor="var(--ods-flamingo-cyan-base)"
+                    cornerColor="var(--ods-flamingo-cyan-base)"
+                  />
+                }
+                aria-label={label}
+                title={label}
+                disabled={disabled}
+                loading={loading}
+                className="bg-ods-card"
+              />
+            </div>
+          );
+        },
         enableSorting: false,
         meta: liveColumnMeta(INCIDENT_COLUMNS.mingo),
       },
       {
         id: 'open',
-        cell: ({ row }: { row: Row<IncidentRow> }) => (
+        cell: ({ row }: { row: Row<IncidentTableRow> }) => (
           <div data-no-row-click className="pointer-events-auto flex items-center justify-end">
             <Button
               onClick={openInNewTab(routes.incidents.details(row.original.id))}
@@ -350,7 +376,7 @@ function IncidentsTableContent({
         meta: liveColumnMeta(INCIDENT_COLUMNS.open),
       },
     ];
-  }, [transition, isMutating, canOpenMingo, typeOptions, customerOptions, severityOptions, statusOptions]);
+  }, [transition, transitionTable, isMutating, typeOptions, customerOptions, severityOptions, statusOptions]);
 
   const filterGroups = [
     { id: INCIDENT_COLUMNS.incident.id, title: 'Category', options: typeOptions },
@@ -380,10 +406,10 @@ function IncidentsTableContent({
     [columnFilters, onFilterChange],
   );
 
-  const table = useDataTable<IncidentRow>({
+  const table = useDataTable<IncidentTableRow>({
     data: rows,
     columns,
-    getRowId: (row: IncidentRow) => row.id,
+    getRowId: (row: IncidentTableRow) => row.id,
     enableSorting: false,
     state: { columnFilters },
     onColumnFiltersChange: handleColumnFiltersChange,
@@ -425,7 +451,7 @@ function IncidentsTableContent({
                 : 'No incidents found. Try adjusting your filters.'
             }
             rowClassName="mb-1"
-            rowHref={(row: IncidentRow) => routes.incidents.details(row.id)}
+            rowHref={(row: IncidentTableRow) => routes.incidents.details(row.id)}
           />
           <DataTable.InfiniteFooter
             hasNextPage={hasNext && !pageFailed}
diff --git a/src/app/(app)/incidents/components/transition-menu-items.tsx b/src/app/(app)/incidents/components/transition-menu-items.tsx
index c5f15565..8697af08 100644
--- a/src/app/(app)/incidents/components/transition-menu-items.tsx
+++ b/src/app/(app)/incidents/components/transition-menu-items.tsx
@@ -9,7 +9,8 @@ import type { ActionsMenuItem } from '@flamingo-stack/openframe-frontend-core/co
 import type { ComponentType } from 'react';
 import type { InsightStatus } from '@/generated/schema-enums';
 import type { TransitionTarget } from '../hooks/use-incident-transitions';
-import { INCIDENT_TRANSITION_ACTIONS, transitionsFrom } from '../utils/incident-labels';
+import { INCIDENT_TRANSITION_ACTIONS } from '../utils/incident-labels';
+import { type IncidentTransitionTable, transitionsFrom } from '../utils/incident-transform';
 
 const TRANSITION_ICON: Record<InsightStatus, ComponentType<{ className?: string }>> = {
   NEW: Refresh01LeftIcon,
@@ -20,16 +21,18 @@ const TRANSITION_ICON: Record<InsightStatus, ComponentType<{ className?: string
 };
 
 /**
- * The status-transition menu — one item per transition the backend allows
- * from the incident's status, so the menu never offers an action that would
- * come back as an error. Shared by the list's row menu and the detail header.
+ * The status-transition menu — one item per transition the server's table
+ * (`insightStatusTransitions`, read into `transitions`) allows from the
+ * incident's status, so the menu never offers an action that would come back
+ * as an error. Shared by the list's row menu and the detail header.
  */
 export function transitionMenuItems(
   incident: TransitionTarget & { status: string },
+  transitions: IncidentTransitionTable,
   transition: (target: TransitionTarget, status: InsightStatus) => void,
   disabled: boolean,
 ): ActionsMenuItem[] {
-  return transitionsFrom(incident.status).map(status => {
+  return transitionsFrom(transitions, incident.status).map(status => {
     const Icon = TRANSITION_ICON[status];
     return {
       id: `transition-${status}`,
diff --git a/src/app/(app)/incidents/hooks/use-fix-with-mingo.ts b/src/app/(app)/incidents/hooks/use-fix-with-mingo.ts
new file mode 100644
index 00000000..68824ee7
--- /dev/null
+++ b/src/app/(app)/incidents/hooks/use-fix-with-mingo.ts
@@ -0,0 +1,96 @@
+'use client';
+
+import { useToast } from '@flamingo-stack/openframe-frontend-core/hooks';
+import { useRef, useState } from 'react';
+import { fetchQuery, useRelayEnvironment } from 'react-relay';
+import type { insightChatPromptRelayQuery as InsightChatPromptQueryType } from '@/__generated__/insightChatPromptRelayQuery.graphql';
+import { openMingoDialogInDrawer } from '@/app/components/notifications/open-mingo-dialog';
+import { insightChatPromptRelayQuery } from '@/graphql/insights/insight-chat-prompt-relay';
+import { getRelayErrorMessage } from '@/lib/handle-api-error';
+import { useMingoLauncherStore } from '../../mingo/stores/mingo-launcher-store';
+import type { DialogNode } from '../../mingo/types';
+import { incidentMingoDraft } from '../utils/fix-with-mingo-draft';
+import type { IncidentRow } from '../utils/incident-transform';
+
+/**
+ * "Fix with Mingo": fetch the server's prompt for the incident and open the
+ * drawer on a fresh chat with it prefilled — nothing sent. `pendingId` is the
+ * incident whose prompt is in flight, for the button that started it.
+ */
+export function useFixWithMingo() {
+  const environment = useRelayEnvironment();
+  const { toast } = useToast();
+  const canOpenMingo = useMingoLauncherStore(state => state.canOpen);
+  const [pendingId, setPendingId] = useState<string | null>(null);
+  // The state is for the buttons; the ref is the guard — two clicks in one
+  // frame read the same stale state.
+  const inFlightRef = useRef(false);
+
+  const fixWithMingo = (incident: IncidentRow) => {
+    if (inFlightRef.current) return;
+    inFlightRef.current = true;
+    setPendingId(incident.id);
+    fetchQuery<InsightChatPromptQueryType>(
+      environment,
+      insightChatPromptRelayQuery,
+      { id: incident.id },
+      { fetchPolicy: 'network-only' },
+    )
+      .toPromise()
+      .then(data => {
+        if (!data) return;
+        useMingoLauncherStore.getState().draftToMingo(incidentMingoDraft(data.insightChatPrompt, incident));
+      })
+      .catch((error: unknown) => {
+        toast({
+          title: 'Error',
+          description: getRelayErrorMessage(error, 'Failed to prepare the Mingo chat'),
+          variant: 'destructive',
+        });
+      })
+      .finally(() => {
+        inFlightRef.current = false;
+        setPendingId(null);
+      });
+  };
+
+  return { fixWithMingo, pendingId, canOpenMingo };
+}
+
+/** What the Mingo button does and says — the header and the table row share one decision. */
+export interface MingoAction {
+  label: 'Fix with Mingo' | 'Open Mingo Session';
+  onClick: () => void;
+  disabled: boolean;
+  loading: boolean;
+}
+
+type MingoControls = ReturnType<typeof useFixWithMingo>;
+
+/**
+ * `session`: the chat about the incident, null for none, undefined while the
+ * lookup is pending (table rows only — the header suspends on it). Inert until
+ * the answer is in and while no drawer is mounted (locked workspace).
+ */
+export function mingoActionFor(
+  incident: IncidentRow,
+  session: DialogNode | null | undefined,
+  { fixWithMingo, canOpenMingo, pendingId }: MingoControls,
+): MingoAction {
+  if (session) {
+    return {
+      label: 'Open Mingo Session',
+      onClick: () => openMingoDialogInDrawer(session.id),
+      // Also while another row's prompt is in flight: that draft, landing,
+      // resets the drawer to a new chat over the conversation just opened.
+      disabled: !canOpenMingo || pendingId !== null,
+      loading: false,
+    };
+  }
+  return {
+    label: 'Fix with Mingo',
+    onClick: () => fixWithMingo(incident),
+    disabled: !canOpenMingo || session === undefined || pendingId !== null,
+    loading: pendingId === incident.id,
+  };
+}
diff --git a/src/app/(app)/incidents/hooks/use-incident-dialogs.ts b/src/app/(app)/incidents/hooks/use-incident-dialogs.ts
new file mode 100644
index 00000000..968366ca
--- /dev/null
+++ b/src/app/(app)/incidents/hooks/use-incident-dialogs.ts
@@ -0,0 +1,86 @@
+'use client';
+
+import { keepPreviousData, queryOptions, useQuery, useQueryClient, useSuspenseQuery } from '@tanstack/react-query';
+import { apiClient } from '@/lib/api-client';
+import { ACTIVE_DIALOG_STATUSES } from '../../mingo/hooks/use-mingo-dialogs';
+import { GET_MINGO_DIALOGS_QUERY } from '../../mingo/queries/dialogs-queries';
+import type { DialogConnection, DialogNode } from '../../mingo/types';
+import type { GraphQlResponse } from '../../tickets/utils/graphql';
+
+/** One freshness policy for one answer, whichever query asks. */
+const DIALOG_LOOKUP_STALE_MS = 30 * 1000;
+
+/**
+ * The latest Mingo chat about an incident, or null — a chat whose first
+ * message carries the incident ("Fix with Mingo" attaches it) is listed under
+ * it, and the Mingo button offers to reopen that instead of starting another.
+ * Only the statuses the drawer can show: an archived chat would leave the
+ * button pointing at a conversation the drawer refuses.
+ *
+ * `/chat/graphql` is the ai-agent (raw POST by design, see the Data Fetching
+ * Strategy). Every failure — transport, or a GraphQL error envelope such as an
+ * ai-agent that does not know the `insightId` filter yet — answers null
+ * without a toast, deliberately: the button then offers a fresh chat, which is
+ * the right fallback, and the header must not fall over because the chat
+ * service did. Keyed under `mingo-dialogs`: the drawer invalidates that on
+ * every dialog it creates, which is exactly when this answer changes.
+ */
+function latestIncidentDialogQuery(insightId: string) {
+  return queryOptions({
+    queryKey: ['mingo-dialogs', 'insight', insightId],
+    queryFn: async (): Promise<DialogNode | null> => {
+      const response = await apiClient.post<GraphQlResponse<{ dialogs: DialogConnection }>>('/chat/graphql', {
+        query: GET_MINGO_DIALOGS_QUERY,
+        variables: {
+          filter: { agentTypes: ['ADMIN'], statuses: ACTIVE_DIALOG_STATUSES, insightId },
+          pagination: { limit: 1 },
+        },
+      });
+      const envelope = response.data;
+      if (!response.ok || !envelope?.data?.dialogs || envelope.errors?.length) {
+        console.warn('[incidents] Mingo session lookup failed:', response.error ?? envelope?.errors);
+        return null;
+      }
+      return envelope.data.dialogs.edges[0]?.node ?? null;
+    },
+    staleTime: DIALOG_LOOKUP_STALE_MS,
+  });
+}
+
+/** The detail header's answer. Suspends, so the header renders once with the right button — no spinner, no relabel. */
+export function useLatestIncidentDialog(insightId: string): DialogNode | null {
+  return useSuspenseQuery(latestIncidentDialogQuery(insightId)).data;
+}
+
+/** Per incident: the chat, null for none, undefined while the lookup is pending. */
+export type IncidentDialogLookup = Readonly<Record<string, DialogNode | null | undefined>>;
+
+const NO_LOOKUP: IncidentDialogLookup = {};
+
+/**
+ * The table's answers. The API filters by a single `insightId`, so this is one
+ * request per row — but ONE query for the table, keyed on the id set, whose
+ * function fans out through `fetchQuery` so each per-incident answer lands in
+ * the cache entry the detail header reads. (Per-row `useQueries` was tried: a
+ * fresh query list and combine per render churned the observer, and the rows
+ * need a stable answer object.) `keepPreviousData` keeps the known rows
+ * answered while a scrolled-in page adds ids. The per-id query never rejects,
+ * so one bad row cannot blank the column.
+ */
+export function useLatestIncidentDialogs(insightIds: readonly string[]): IncidentDialogLookup {
+  const queryClient = useQueryClient();
+  const ids = [...insightIds].sort();
+  const query = useQuery({
+    queryKey: ['mingo-dialogs', 'insights', ids],
+    queryFn: async (): Promise<IncidentDialogLookup> => {
+      const entries = await Promise.all(
+        ids.map(async id => [id, await queryClient.fetchQuery(latestIncidentDialogQuery(id))] as const),
+      );
+      return Object.fromEntries(entries);
+    },
+    enabled: ids.length > 0,
+    staleTime: DIALOG_LOOKUP_STALE_MS,
+    placeholderData: keepPreviousData,
+  });
+  return query.data ?? NO_LOOKUP;
+}
diff --git a/src/app/(app)/incidents/hooks/use-incident.ts b/src/app/(app)/incidents/hooks/use-incident.ts
index ac28337c..e7cca559 100644
--- a/src/app/(app)/incidents/hooks/use-incident.ts
+++ b/src/app/(app)/incidents/hooks/use-incident.ts
@@ -4,7 +4,12 @@ import { useLazyLoadQuery } from 'react-relay';
 import type { incidentDetailRelayQuery as IncidentDetailQueryType } from '@/__generated__/incidentDetailRelayQuery.graphql';
 import { useRetryKey } from '@/app/components/shared';
 import { incidentDetailRelayQuery } from '@/graphql/insights/incident-detail-relay';
-import { type Incident, toIncident } from '../utils/incident-transform';
+import {
+  type Incident,
+  type IncidentTransitionTable,
+  toIncident,
+  toTransitionTable,
+} from '../utils/incident-transform';
 
 /**
  * The detail page's record, for every island that draws it. One place for the
@@ -14,11 +19,16 @@ import { type Incident, toIncident } from '../utils/incident-transform';
  * replays a retained rejection after Retry (see `ScriptSummary`).
  */
 export function useIncident(incidentId: string): Incident {
+  return useIncidentDetail(incidentId).incident;
+}
+
+/** The record plus the status-transition table that rides on the same query (the header needs both). */
+export function useIncidentDetail(incidentId: string): { incident: Incident; transitions: IncidentTransitionTable } {
   const retryKey = useRetryKey();
   const data = useLazyLoadQuery<IncidentDetailQueryType>(
     incidentDetailRelayQuery,
     { id: incidentId },
     { fetchPolicy: 'store-and-network', fetchKey: retryKey },
   );
-  return toIncident(data.insight);
+  return { incident: toIncident(data.insight), transitions: toTransitionTable(data) };
 }
diff --git a/src/app/(app)/incidents/utils/fix-with-mingo-draft.test.ts b/src/app/(app)/incidents/utils/fix-with-mingo-draft.test.ts
new file mode 100644
index 00000000..ab940a6c
--- /dev/null
+++ b/src/app/(app)/incidents/utils/fix-with-mingo-draft.test.ts
@@ -0,0 +1,54 @@
+import { describe, expect, it } from 'vitest';
+import { InsightSeverity, InsightStatus, InsightType } from '@/generated/schema-enums';
+import { incidentMingoDraft } from './fix-with-mingo-draft';
+import type { IncidentRow } from './incident-transform';
+
+const incident: IncidentRow = {
+  id: 'SW5zaWdodDpxYS1pbnNpZ2h0LTI',
+  insightId: 'qa-insight-2',
+  title: 'macOS firewall is off',
+  type: InsightType.SECURITY,
+  severity: InsightSeverity.HIGH,
+  status: InsightStatus.NEW,
+  snoozedUntil: null,
+  detectedAt: '2026-09-16T23:02:00Z',
+  machineId: 'm-1',
+  hasDevice: true,
+  deviceName: 'MacBook-Pro-Kirill.local',
+  deviceType: 'laptop',
+  organizationId: 'o-1',
+  organizationName: 'куукку',
+};
+
+describe('incidentMingoDraft', () => {
+  it('turns the leading markers into labelled mentions and keeps the ask as text', () => {
+    const draft = incidentMingoDraft(
+      '@insight:qa-insight-2 @device:m-1\n\nUsing the insight and device context, investigate this problem.',
+      incident,
+    );
+    expect(draft.mentions).toEqual([
+      { type: 'INSIGHT', id: 'qa-insight-2', label: 'macOS firewall is off' },
+      { type: 'DEVICE', id: 'm-1', label: 'MacBook-Pro-Kirill.local' },
+    ]);
+    expect(draft.text).toBe('Using the insight and device context, investigate this problem.');
+  });
+
+  it('labels an unexpected id with the id itself and keeps an unknown marker in the text', () => {
+    const draft = incidentMingoDraft('@insight:other @widget:w-1 look', incident);
+    expect(draft.mentions).toEqual([{ type: 'INSIGHT', id: 'other', label: 'other' }]);
+    expect(draft.text).toBe('@widget:w-1 look');
+  });
+
+  it('reads the markers after an unknown one', () => {
+    const draft = incidentMingoDraft('@widget:w-1 @device:m-1 look', incident);
+    expect(draft.mentions).toEqual([{ type: 'DEVICE', id: 'm-1', label: 'MacBook-Pro-Kirill.local' }]);
+    expect(draft.text).toBe('@widget:w-1 look');
+  });
+
+  it('copes with a prompt that has no markers', () => {
+    expect(incidentMingoDraft('just text', incident)).toEqual({
+      text: 'just text',
+      mentions: [],
+    });
+  });
+});
diff --git a/src/app/(app)/incidents/utils/fix-with-mingo-draft.ts b/src/app/(app)/incidents/utils/fix-with-mingo-draft.ts
new file mode 100644
index 00000000..2f8beb7d
--- /dev/null
+++ b/src/app/(app)/incidents/utils/fix-with-mingo-draft.ts
@@ -0,0 +1,43 @@
+import { CONTEXT_ENTITY_KIND, CONTEXT_ENTITY_MARKER, type ContextEntityKind } from '../../mingo/context/context-types';
+import type { MingoDraft } from '../../mingo/stores/mingo-launcher-store';
+import type { IncidentRow } from './incident-transform';
+
+const KIND_BY_MARKER = new Map<string, ContextEntityKind>(
+  (Object.entries(CONTEXT_ENTITY_MARKER) as [ContextEntityKind, string][]).map(([kind, marker]) => [marker, kind]),
+);
+
+/** One leading `@marker:id` token of the server prompt. */
+const LEADING_MARKER = /^@([A-Za-z]+):(\S+)\s*/;
+
+/**
+ * The composer draft for "Fix with Mingo", from the server's `insightChatPrompt`.
+ *
+ * The prompt opens with the context markers (`@insight:<stored id> @device:<machineId>`)
+ * and continues with the ask. The markers become ATTACHED mentions rather than
+ * text — a `@marker:id` left in the text is parsed into a chip labelled with the
+ * id and outside the context strip — with the labels the row already knows;
+ * the ask stays as the text. A marker of a kind this build does not know is
+ * kept in the text rather than dropped, and does not stop the ones after it
+ * from being read.
+ */
+export function incidentMingoDraft(prompt: string, incident: IncidentRow): MingoDraft {
+  const mentions: NonNullable<MingoDraft['mentions']> = [];
+  const unknown: string[] = [];
+  let rest = prompt.trimStart();
+  for (;;) {
+    const match = LEADING_MARKER.exec(rest);
+    if (!match) break;
+    const [token, marker, id] = match;
+    rest = rest.slice(token.length);
+    const kind = KIND_BY_MARKER.get(marker);
+    if (kind) mentions.push({ type: kind, id, label: labelFor(kind, id, incident) });
+    else unknown.push(token.trim());
+  }
+  return { text: [...unknown, rest.trim()].filter(Boolean).join(' '), mentions };
+}
+
+function labelFor(kind: ContextEntityKind, id: string, incident: IncidentRow): string {
+  if (kind === CONTEXT_ENTITY_KIND.INSIGHT && id === incident.insightId) return incident.title;
+  if (kind === CONTEXT_ENTITY_KIND.DEVICE && id === incident.machineId) return incident.deviceName;
+  return id;
+}
diff --git a/src/app/(app)/incidents/utils/fix-with-mingo-prompt.ts b/src/app/(app)/incidents/utils/fix-with-mingo-prompt.ts
deleted file mode 100644
index ac7f3e91..00000000
--- a/src/app/(app)/incidents/utils/fix-with-mingo-prompt.ts
+++ /dev/null
@@ -1,66 +0,0 @@
-import { formatDateTime } from '@/lib/format-date';
-import { CONTEXT_ENTITY_KIND } from '../../mingo/context/context-types';
-import type { MingoDraft } from '../../mingo/stores/mingo-launcher-store';
-import { INCIDENT_SEVERITY_LABELS, INCIDENT_TYPE_LABELS, labelOf } from './incident-labels';
-import type { Incident, IncidentRow } from './incident-transform';
-
-/** Evidence rows past this many are summarized as a count — the prompt is for a chat, not a report. */
-const MAX_EVIDENCE_ROWS = 10;
-
-/**
- * The draft "Fix with Mingo" puts in a fresh Mingo composer — NOT sent; the
- * technician reads it, edits it, and decides. The incident rides along twice:
- * as an attached `@insight:<id>` context chip (what the ai-agent resolves once
- * its insight resolver is real — today it answers "not available in this
- * build") and spelled out in the text, so the prompt is useful either way. The
- * detail page passes the full `Incident`, so the description and evidence
- * ride along.
- */
-export function incidentMingoDraft(incident: IncidentRow | Incident): MingoDraft {
-  return {
-    text: incidentMingoPrompt(incident),
-    // The device rides as a chip too (raw `machineId`, what the DEVICE resolver
-    // and `@device:` marker take) rather than as a `@device:` token in the text —
-    // the composer would parse that into an id-labelled chip that is not in the
-    // context strip.
-    mentions: [
-      { type: CONTEXT_ENTITY_KIND.INSIGHT, id: incident.id, label: incident.title },
-      { type: CONTEXT_ENTITY_KIND.DEVICE, id: incident.machineId, label: incident.deviceName },
-    ],
-  };
-}
-
-function incidentMingoPrompt(incident: IncidentRow | Incident): string {
-  const customer = incident.organizationName ? ` (${incident.organizationName})` : '';
-  const lines = [
-    `Incident: ${incident.title}`,
-    `Category: ${labelOf(INCIDENT_TYPE_LABELS, incident.type)} · Severity: ${labelOf(INCIDENT_SEVERITY_LABELS, incident.severity)}`,
-    `Device: ${incident.deviceName}${customer}`,
-    `Detected: ${formatDateTime(incident.detectedAt)}`,
-  ];
-
-  if ('description' in incident && incident.description) {
-    lines.push(`What the check looks for: ${incident.description}`);
-  }
-
-  if ('queryResult' in incident && incident.queryResult && incident.queryResult.length > 0) {
-    const rows = incident.queryResult;
-    lines.push('', `Evidence (${rows.length} row${rows.length === 1 ? '' : 's'} from the latest run):`);
-    for (const row of rows.slice(0, MAX_EVIDENCE_ROWS)) {
-      lines.push(
-        `- ${Object.entries(row)
-          .map(([key, value]) => `${key}: ${value ?? '—'}`)
-          .join(', ')}`,
-      );
-    }
-    if (rows.length > MAX_EVIDENCE_ROWS) {
-      lines.push(`- … and ${rows.length - MAX_EVIDENCE_ROWS} more`);
-    }
-  }
-
-  lines.push(
-    '',
-    'Investigate this incident on the device, explain what it means and how urgent it is, and propose a fix.',
-  );
-  return lines.join('\n');
-}
diff --git a/src/app/(app)/incidents/utils/incident-labels.ts b/src/app/(app)/incidents/utils/incident-labels.ts
index 4c94e58c..6b0a8459 100644
--- a/src/app/(app)/incidents/utils/incident-labels.ts
+++ b/src/app/(app)/incidents/utils/incident-labels.ts
@@ -30,26 +30,6 @@ export function labelOf(labels: Record<string, string>, value: string): string {
   return labels[value] ?? value;
 }
 
-/**
- * Which statuses an incident may move to from each status — a mirror of the
- * backend's `InsightStatusTransitionValidator`, so the UI offers only actions
- * the server will accept. Archiving is reachable only from RESOLVED: an
- * incident is filed away after it was dealt with, never instead of it.
- */
-const INCIDENT_TRANSITIONS: Record<InsightStatus, readonly InsightStatus[]> = {
-  NEW: [InsightStatus.ACKNOWLEDGED, InsightStatus.SNOOZED, InsightStatus.RESOLVED],
-  ACKNOWLEDGED: [InsightStatus.SNOOZED, InsightStatus.RESOLVED],
-  SNOOZED: [InsightStatus.ACKNOWLEDGED, InsightStatus.RESOLVED],
-  RESOLVED: [InsightStatus.ARCHIVED, InsightStatus.NEW],
-  ARCHIVED: [InsightStatus.NEW],
-};
-
-/** Transitions offered from `status`; none for a status this build does not know (`"%future added value"`). */
-export function transitionsFrom(status: string): readonly InsightStatus[] {
-  const transitions: Record<string, readonly InsightStatus[]> = INCIDENT_TRANSITIONS;
-  return transitions[status] ?? [];
-}
-
 /** How a transition INTO each status is named: the menu item, and the past tense the toast uses. */
 export const INCIDENT_TRANSITION_ACTIONS: Record<InsightStatus, { label: string; done: string }> = {
   NEW: { label: 'Reopen', done: 'reopened' },
diff --git a/src/app/(app)/incidents/utils/incident-transform.ts b/src/app/(app)/incidents/utils/incident-transform.ts
index fcb03cb7..dba702e9 100644
--- a/src/app/(app)/incidents/utils/incident-transform.ts
+++ b/src/app/(app)/incidents/utils/incident-transform.ts
@@ -5,13 +5,18 @@ import type {
   insightRowFields_insight$data,
   insightRowFields_insight$key,
 } from '@/__generated__/insightRowFields_insight.graphql';
+import type { insightTransitions_query$key } from '@/__generated__/insightTransitions_query.graphql';
 import type { insightUserFields_user$key } from '@/__generated__/insightUserFields_user.graphql';
 import { DELETED_EMPLOYEE_LABEL, isDeletedUserStatus } from '@/app/components/shared/deleted-user';
+import { InsightStatus } from '@/generated/schema-enums';
 import { insightFieldsFragment } from '@/graphql/insights/insight-fields';
 import { insightRowFieldsFragment } from '@/graphql/insights/insight-row-fields';
+import { insightTransitionsFragment } from '@/graphql/insights/insight-transitions';
 import { insightUserFieldsFragment } from '@/graphql/insights/insight-user-fields';
 import { getFullImageUrl } from '@/lib/image-url';
+import { rawIdOf } from '@/lib/relay-id';
 import { getDeviceName } from '../../devices/utils/device-name';
+import { enumMembers } from './incident-labels';
 
 /**
  * A row of the Incidents table. The enum fields keep the artifact's own union
@@ -21,6 +26,12 @@ import { getDeviceName } from '../../devices/utils/device-name';
  */
 export interface IncidentRow {
   id: string;
+  /**
+   * The STORED id (`id` is the Relay global handle around it) — what the
+   * ai-agent's insight resolver looks up, so it is what every Mingo context
+   * reference (`@insight:` chip, open view, dialog link) carries.
+   */
+  insightId: string;
   title: string;
   type: insightRowFields_insight$data['type'];
   severity: insightRowFields_insight$data['severity'];
@@ -43,6 +54,7 @@ export function toIncidentRow(ref: insightRowFields_insight$key): IncidentRow {
   const machine = node.machine;
   return {
     id: node.id,
+    insightId: rawIdOf(node.id),
     title: node.title,
     type: node.type,
     severity: node.severity,
@@ -121,3 +133,20 @@ export function toIncident(ref: insightFields_insight$key): Incident {
     organizationImageUrl: getFullImageUrl(node.organization?.image?.imageUrl, node.organization?.image?.hash),
   };
 }
+
+/** Which statuses an incident may move to from each status — the server's table, keyed by `from`. */
+export type IncidentTransitionTable = Readonly<Record<string, readonly InsightStatus[]>>;
+
+/** `insightStatusTransitions` as a lookup. Statuses this build does not know are dropped, not offered. */
+export function toTransitionTable(ref: insightTransitions_query$key): IncidentTransitionTable {
+  const data = readInlineData(insightTransitionsFragment, ref);
+  const table: Record<string, readonly InsightStatus[]> = {};
+  for (const entry of data.insightStatusTransitions) {
+    table[entry.from] = enumMembers(entry.to, InsightStatus);
+  }
+  return table;
+}
+
+export function transitionsFrom(table: IncidentTransitionTable, status: string): readonly InsightStatus[] {
+  return table[status] ?? [];
+}
diff --git a/src/app/(app)/mingo/context/context-types.ts b/src/app/(app)/mingo/context/context-types.ts
index 46124cfa..0b1d2bfe 100644
--- a/src/app/(app)/mingo/context/context-types.ts
+++ b/src/app/(app)/mingo/context/context-types.ts
@@ -44,7 +44,10 @@ export const CONTEXT_ENTITY_KIND = {
   POLICY: 'POLICY',
   QUERY: 'QUERY',
   SCHEDULED_SCRIPT: 'SCHEDULED_SCRIPT',
-  /** An incident (the API's `Insight`); the marker is `@insight:<Insight.id>`. */
+  /**
+   * An incident (the API's `Insight`); the marker is `@insight:<stored id>` —
+   * the id INSIDE the Relay handle, like every other kind.
+   */
   INSIGHT: 'INSIGHT',
 } as const;
 
@@ -98,8 +101,9 @@ export const CONTEXT_RELAY_TYPENAME: Partial<Record<ContextEntityKind, string>>
   KB_FOLDER: 'KnowledgeBaseItem',
   SCRIPT: 'Script',
   SCHEDULED_SCRIPT: 'ScriptSchedule',
-  // `Insight.id` is ALREADY the opaque global id (the `insight(id:)` query takes
-  // it as is), so `ensureGlobalIdForType` passes it through untouched.
+  // An INSIGHT reference carries the STORED id (what the ai-agent's resolver looks
+  // up); the chip re-encodes it through `ensureGlobalIdForType('Insight', …)` for
+  // the `insight(id:)` query, which takes the global handle.
   INSIGHT: 'Insight',
 };
 
diff --git a/src/app/(app)/mingo/context/relay-items.tsx b/src/app/(app)/mingo/context/relay-items.tsx
index 2a465f3e..589d03e4 100644
--- a/src/app/(app)/mingo/context/relay-items.tsx
+++ b/src/app/(app)/mingo/context/relay-items.tsx
@@ -36,7 +36,7 @@ import { DEFAULT_DEVICES_LIST_STATUSES } from '@/app/(app)/devices/constants/dev
 import { getDeviceName } from '@/app/(app)/devices/utils/device-name';
 import { INCIDENT_SEVERITY_LABELS, labelOf, WORKING_SET_STATUSES } from '@/app/(app)/incidents/utils/incident-labels';
 import { toRelayDeviceFilter } from '@/graphql/devices/to-relay-device-filter';
-import { decodeGlobalId } from '@/lib/relay-id';
+import { decodeGlobalId, rawIdOf } from '@/lib/relay-id';
 import { CONTEXT_ENTITY_KIND } from './context-types';
 import { type ContextItemsProps, MINGO_CONTEXT_PAGE_SIZE } from './items-shared';
 
@@ -179,7 +179,7 @@ export function OrganizationItems({ query, selectedKeys, onToggle, atLimit }: Co
                 type: CONTEXT_ENTITY_KIND.ORGANIZATION,
                 // Raw db id (organizationId), decoded from the global `id`
                 // (`base64("Organization:<rawId>")`); the chip re-encodes it.
-                id: decodeGlobalId(e.node.id)?.rawId ?? e.node.id,
+                id: rawIdOf(e.node.id),
                 label: e.node.name || e.node.id,
                 description: e.node.category ?? undefined,
               },
@@ -249,7 +249,7 @@ export function KnowledgeBaseItems({ query, selectedKeys, onToggle, atLimit }: C
                 type: CONTEXT_ENTITY_KIND.KB_ARTICLE,
                 // Raw db id, decoded from the global `id`
                 // (`base64("KnowledgeBaseItem:<rawId>")`); the chip re-encodes it.
-                id: decodeGlobalId(e.node.id)?.rawId ?? e.node.id,
+                id: rawIdOf(e.node.id),
                 label: e.node.name || e.node.id,
                 description: e.node.type ?? undefined,
               },
@@ -486,7 +486,7 @@ export function IncidentItems({ query, selectedKeys, onToggle, atLimit }: Contex
         return [
           {
             type: CONTEXT_ENTITY_KIND.INSIGHT,
-            id: e.node.id,
+            id: rawIdOf(e.node.id),
             label: e.node.title,
             description: [labelOf(INCIDENT_SEVERITY_LABELS, e.node.severity), device].filter(Boolean).join(' · '),
           },
diff --git a/src/app/(app)/mingo/hooks/use-mingo-chat.ts b/src/app/(app)/mingo/hooks/use-mingo-chat.ts
index 8e8e68e0..45d7a49f 100644
--- a/src/app/(app)/mingo/hooks/use-mingo-chat.ts
+++ b/src/app/(app)/mingo/hooks/use-mingo-chat.ts
@@ -53,7 +53,8 @@ interface UseMingoChat {
   isLoading: boolean;
 
   // Actions
-  createDialog: () => Promise<string | null>;
+  /** `insightId`: the stored id of the incident the chat is about, for the server to list it under. */
+  createDialog: (insightId?: string) => Promise<string | null>;
   sendMessage: (content: string, targetDialogId?: string, context?: MingoSendContext) => Promise<boolean>;
   stopGeneration: () => Promise<void>;
 
@@ -195,32 +196,35 @@ export function useMingoChat(dialogId: string | null): UseMingoChat {
     return tail?.type === 'context_compaction' && tail.status === 'started';
   }, [dialogId, messagesByDialog]);
 
-  const createDialog = useCallback(async (): Promise<string | null> => {
-    if (isCreatingDialog) return null;
+  const createDialog = useCallback(
+    async (insightId?: string): Promise<string | null> => {
+      if (isCreatingDialog) return null;
 
-    try {
-      setCreatingDialog(true);
+      try {
+        setCreatingDialog(true);
 
-      const result = await createDialogMutation.mutateAsync();
-      queryClient.invalidateQueries({ queryKey: ['mingo-dialogs'] });
+        const result = await createDialogMutation.mutateAsync({ insightId });
+        queryClient.invalidateQueries({ queryKey: ['mingo-dialogs'] });
 
-      return result.id;
-    } catch (error) {
-      console.error('[MingoChat] Failed to create dialog:', error);
-      // Surface the failure: callers (quick actions, launcher, draft send) only
-      // get a null id back and otherwise bail silently, so without this a dialog
-      // that can't be created leaves the user with no feedback.
-      toast({
-        title: 'Failed to start conversation',
-        description: error instanceof Error ? error.message : 'Could not create a new chat',
-        variant: 'destructive',
-        duration: 5000,
-      });
-      return null;
-    } finally {
-      setCreatingDialog(false);
-    }
-  }, [isCreatingDialog, setCreatingDialog, createDialogMutation, queryClient, toast]);
+        return result.id;
+      } catch (error) {
+        console.error('[MingoChat] Failed to create dialog:', error);
+        // Surface the failure: callers (quick actions, launcher, draft send) only
+        // get a null id back and otherwise bail silently, so without this a dialog
+        // that can't be created leaves the user with no feedback.
+        toast({
+          title: 'Failed to start conversation',
+          description: error instanceof Error ? error.message : 'Could not create a new chat',
+          variant: 'destructive',
+          duration: 5000,
+        });
+        return null;
+      } finally {
+        setCreatingDialog(false);
+      }
+    },
+    [isCreatingDialog, setCreatingDialog, createDialogMutation, queryClient, toast],
+  );
 
   const sendMessage = useCallback(
     async (content: string, targetDialogId?: string, context?: MingoSendContext): Promise<boolean> => {
diff --git a/src/app/(app)/mingo/hooks/use-mingo-dialogs.ts b/src/app/(app)/mingo/hooks/use-mingo-dialogs.ts
index b8c56d30..7f0931e3 100644
--- a/src/app/(app)/mingo/hooks/use-mingo-dialogs.ts
+++ b/src/app/(app)/mingo/hooks/use-mingo-dialogs.ts
@@ -14,10 +14,12 @@ import { isAwaitingGeneratedTitle } from './use-mingo-dialog-selection';
 // temporary workaround — disabled for now; flip this flag to restore it.
 const HIGHLIGHT_UNREAD_FROM_NOTIFICATIONS: boolean = false;
 
-// Statuses shown in the active "Current Chats" list — every DialogStatus except
-// ARCHIVED. The backend returns archived dialogs when no statuses are passed, so
-// list them explicitly; archived dialogs live in the separate Chat Archive page.
-const ACTIVE_DIALOG_STATUSES = ['ACTIVE', 'ACTION_REQUIRED', 'ON_HOLD', 'RESOLVED'] as const;
+/**
+ * The statuses the drawer's list shows. Sent explicitly because the backend
+ * returns ARCHIVED dialogs too when no statuses are passed — and a dialog
+ * outside this set cannot be opened in the drawer.
+ */
+export const ACTIVE_DIALOG_STATUSES = ['ACTIVE', 'ACTION_REQUIRED', 'ON_HOLD', 'RESOLVED'] as const;
 
 function transformToDialogItem(dialog: DialogNode, unreadCount: number = 0): DialogItem {
   // Admin owner → trailing avatar in the chat-history rows (Figma 113:63224).
diff --git a/src/app/(app)/mingo/hooks/use-mingo-unified-chat-state.ts b/src/app/(app)/mingo/hooks/use-mingo-unified-chat-state.ts
index 5e2a4106..8516997b 100644
--- a/src/app/(app)/mingo/hooks/use-mingo-unified-chat-state.ts
+++ b/src/app/(app)/mingo/hooks/use-mingo-unified-chat-state.ts
@@ -40,7 +40,12 @@ import { useCallback, useDeferredValue, useMemo, useState } from 'react';
 import { useAuthStore } from '@/app/(auth)/auth/stores/auth-store';
 import { useAiModelStatus } from '@/app/hooks/use-ai-model';
 import { EVENT_SUBTYPE, trackDashboardActivity } from '@/lib/analytics';
-import { CONTEXT_ITEMS_MAX, RECENT_VIEWS_MAX } from '../context/context-types';
+import {
+  CONTEXT_ENTITY_KIND,
+  CONTEXT_ENTITY_MARKER,
+  CONTEXT_ITEMS_MAX,
+  RECENT_VIEWS_MAX,
+} from '../context/context-types';
 import { useMingoContextStore } from '../stores/mingo-context-store';
 import { useMingoMessagesStore } from '../stores/mingo-messages-store';
 import { type MingoSendContext, useMingoChat } from './use-mingo-chat';
@@ -50,6 +55,9 @@ import { useMingoDialogs } from './use-mingo-dialogs';
 import { useMingoRealtimeSubscription } from './use-mingo-realtime-subscription';
 
 const ADMIN_CHAT_TYPE = 'ADMIN_AI_CHAT' as const;
+
+/** The composer's inline incident mention: `@insight:<stored id>`, a whole token. */
+const INSIGHT_MENTION = new RegExp(`(?:^|\\s)@${CONTEXT_ENTITY_MARKER.INSIGHT}:(\\S+)`);
 const WELCOME_TEXT = "Hi! I'm Mingo AI, ready to help with your technical tasks. What can I do for you?";
 
 /** Metadata frame shape emitted by `<DialogSubscription onMetadata>`. */
@@ -353,7 +361,17 @@ export function useMingoUnifiedChatState(): MingoUnifiedChat {
       const trimmed = text.trim();
       if (!trimmed) return;
 
-      const newId = await createDialog();
+      // A chat whose first message references an incident is listed under it.
+      // Read off the message itself, so nothing else's first send — a
+      // quick-action chip, a launcher prompt — can inherit a stale link. The
+      // strip is one carrier; the `@insight:<id>` token in the text is the
+      // other, and the one that holds on the "Fix with Mingo" path: the
+      // prefilled mention reached the send as text with `contextItems` absent
+      // (observed), and the token is what the server resolves anyway.
+      const insightId =
+        context?.contextItems?.find(item => item.type === CONTEXT_ENTITY_KIND.INSIGHT)?.id ??
+        INSIGHT_MENTION.exec(trimmed)?.[1];
+      const newId = await createDialog(insightId);
       if (!newId) return;
       addMessage(newId, {
         id: `welcome-${newId}`,
diff --git a/src/app/(app)/mingo/services/mingo-api-service.ts b/src/app/(app)/mingo/services/mingo-api-service.ts
index b3b03212..a7e94406 100644
--- a/src/app/(app)/mingo/services/mingo-api-service.ts
+++ b/src/app/(app)/mingo/services/mingo-api-service.ts
@@ -25,6 +25,8 @@ export interface ApprovalResponse {
 
 export interface CreateDialogRequest {
   agentType: 'ADMIN';
+  /** The STORED insight id when the chat is about an incident — the server lists the chat under it. */
+  insightId?: string;
 }
 
 /** Minimal entity ref carried in the message payload. */
@@ -57,10 +59,9 @@ export interface SendMessageRequest {
  */
 export function useCreateDialogMutation() {
   return useMutation({
-    mutationFn: async (): Promise<CreateDialogResponse> => {
-      const response = await apiClient.post<CreateDialogResponse>('/chat/api/v1/dialogs', {
-        agentType: 'ADMIN',
-      } as CreateDialogRequest);
+    mutationFn: async ({ insightId }: Pick<CreateDialogRequest, 'insightId'> = {}): Promise<CreateDialogResponse> => {
+      const request: CreateDialogRequest = { agentType: 'ADMIN', ...(insightId && { insightId }) };
+      const response = await apiClient.post<CreateDialogResponse>('/chat/api/v1/dialogs', request);
 
       if (!response.ok) {
         throw new Error(response.error || `Failed to create dialog with status ${response.status}`);
diff --git a/src/app/(app)/mingo/stores/mingo-launcher-store.ts b/src/app/(app)/mingo/stores/mingo-launcher-store.ts
index 06d40a5a..7fcd5d70 100644
--- a/src/app/(app)/mingo/stores/mingo-launcher-store.ts
+++ b/src/app/(app)/mingo/stores/mingo-launcher-store.ts
@@ -126,7 +126,13 @@ export const useMingoLauncherStore = create<MingoLauncherStore>()(
 
       startNewChat: () =>
         set(
-          { isOpen: true, pendingNewChat: true, pendingPrompt: null, pendingDraft: null, closedForNavigation: false },
+          {
+            isOpen: true,
+            pendingNewChat: true,
+            pendingPrompt: null,
+            pendingDraft: null,
+            closedForNavigation: false,
+          },
           false,
           'startNewChat',
         ),
diff --git a/src/app/(app)/tickets/components/create-edit/ticket-form-fields.tsx b/src/app/(app)/tickets/components/create-edit/ticket-form-fields.tsx
index 165d6dcd..726e6b9d 100644
--- a/src/app/(app)/tickets/components/create-edit/ticket-form-fields.tsx
+++ b/src/app/(app)/tickets/components/create-edit/ticket-form-fields.tsx
@@ -348,7 +348,8 @@ export function TicketFormFields({
           <AssignmentsField
             value={field.value ?? {}}
             onChange={field.onChange}
-            enabledTypes={['ORGANIZATION', 'DEVICE', 'KNOWLEDGE_ARTICLE']}
+            // INSIGHT is not pickable: the row shows the incident the ticket is filed from (seeded from the prefill).
+            enabledTypes={['ORGANIZATION', 'DEVICE', 'KNOWLEDGE_ARTICLE', 'INSIGHT']}
           />
         )}
       />
diff --git a/src/app/(app)/tickets/hooks/use-create-ticket-form.ts b/src/app/(app)/tickets/hooks/use-create-ticket-form.ts
index 33d41243..6ea7ecc6 100644
--- a/src/app/(app)/tickets/hooks/use-create-ticket-form.ts
+++ b/src/app/(app)/tickets/hooks/use-create-ticket-form.ts
@@ -81,7 +81,12 @@ export function useCreateTicketForm({ ticketId, prefill }: UseCreateTicketFormOp
       tagIds: [],
       description: prefill?.description ?? '',
       assignKnowledgeBase: false,
-      assignments: {},
+      // Filed from an incident: the link is an assignment row on the form (read-only)
+      // and goes out as `CreateTicketInput.insightId` — the server owns the
+      // incident → ticket assignment, so it is not written through `assignItem`.
+      assignments: prefill?.insightId
+        ? { INSIGHT: [{ id: prefill.insightId, label: prefill.insightTitle || prefill.insightId }] }
+        : {},
     },
   });
 
@@ -188,6 +193,7 @@ export function useCreateTicketForm({ ticketId, prefill }: UseCreateTicketFormOp
           organizationId: data.organizationId || undefined,
           deviceId: data.deviceId || undefined,
           assigneeId: data.assignedTo || undefined,
+          insightId: nextAssignments.INSIGHT?.[0]?.id,
           tagIds: tagIds.length ? tagIds : undefined,
           tempAttachmentIds: tempAttachmentIds.length ? tempAttachmentIds : undefined,
         });
diff --git a/src/app/(app)/tickets/types/ticket.types.ts b/src/app/(app)/tickets/types/ticket.types.ts
index f597df88..e609313f 100644
--- a/src/app/(app)/tickets/types/ticket.types.ts
+++ b/src/app/(app)/tickets/types/ticket.types.ts
@@ -135,6 +135,8 @@ export interface CreateTicketInput {
   deviceId?: string;
   organizationId?: string;
   assigneeId?: string;
+  /** Raw insight id when the ticket is filed from an incident; links the two on create. */
+  insightId?: string;
   tagIds?: string[];
   linkedArticleIds?: string[];
   tempAttachmentIds?: string[];
diff --git a/src/app/components/shared/notes-section.tsx b/src/app/components/shared/notes-section.tsx
index aa563f00..27c270c2 100644
--- a/src/app/components/shared/notes-section.tsx
+++ b/src/app/components/shared/notes-section.tsx
@@ -189,10 +189,15 @@ function NotesSectionFrame({ children }: { children: ReactNode }) {
 }
 
 /** The heading with a bar where the first note lands. */
+/**
+ * The heading over an "Add Note" sized bar — the shape of the loaded section
+ * when there are no notes yet, which is what most records have. Notes, when
+ * there are any, grow the section either way.
+ */
 export function NotesSectionSkeleton() {
   return (
     <NotesSectionFrame>
-      <Skeleton className="h-20 w-full rounded-md" />
+      <Skeleton className="h-8 w-28 rounded-md" />
     </NotesSectionFrame>
   );
 }
diff --git a/src/components/assignments/assigned-items-view.tsx b/src/components/assignments/assigned-items-view.tsx
index 4cbb1312..5ab15dd3 100644
--- a/src/components/assignments/assigned-items-view.tsx
+++ b/src/components/assignments/assigned-items-view.tsx
@@ -7,7 +7,7 @@ import { DevicesAssignedTable } from './tables/devices-assigned-table';
 import { KnowledgeBaseAssignedTable } from './tables/knowledge-base-assigned-table';
 import { TicketsAssignedTable } from './tables/tickets-assigned-table';
 import { TARGET_CONFIG } from './target-config';
-import { ASSIGNMENT_TARGET_TYPES, type AssignmentItemType, type AssignmentTargetType } from './types';
+import { ASSIGNMENT_TARGET_TYPES, type AssignmentItemType, type ServerAssignmentTargetType } from './types';
 import { useAssignedItems } from './use-assigned-items';
 
 export interface AssignedItemsViewProps {
@@ -24,7 +24,7 @@ export function AssignedItemsView({ itemId, itemType, className, showTitle = tru
 
   const activeTypes = useMemo(() => ASSIGNMENT_TARGET_TYPES.filter(type => (value[type]?.length ?? 0) > 0), [value]);
 
-  const [pinnedTab, setPinnedTab] = useState<AssignmentTargetType | null>(null);
+  const [pinnedTab, setPinnedTab] = useState<ServerAssignmentTargetType | null>(null);
   const activeTab = pinnedTab && activeTypes.includes(pinnedTab) ? pinnedTab : activeTypes[0];
 
   const tabs: TabItem[] = useMemo(
@@ -37,7 +37,7 @@ export function AssignedItemsView({ itemId, itemType, className, showTitle = tru
     [activeTypes],
   );
 
-  const renderTabBody = (type: AssignmentTargetType) => {
+  const renderTabBody = (type: ServerAssignmentTargetType) => {
     switch (type) {
       case 'ORGANIZATION':
         return <CustomersAssignedTable customers={customers ?? []} isLoading={isLoading} />;
@@ -48,7 +48,7 @@ export function AssignedItemsView({ itemId, itemType, className, showTitle = tru
       case 'TICKET':
         return <TicketsAssignedTable tickets={tickets ?? []} isLoading={isLoading} />;
       default: {
-        // `type` is `never` here because the cases above cover AssignmentTargetType.
+        // `type` is `never` here because the cases above cover ServerAssignmentTargetType.
         // Adding a member to that union makes this assignment fail to compile, which
         // is the point — a silent `undefined` tab body would just render nothing.
         const unreachable: never = type;
@@ -76,9 +76,13 @@ export function AssignedItemsView({ itemId, itemType, className, showTitle = tru
         {activeTypes.length === 1 ? (
           <div className="p-[var(--spacing-system-mf)]">{renderTabBody(activeTypes[0])}</div>
         ) : (
-          <TabNavigation tabs={tabs} activeTab={activeTab} onTabChange={id => setPinnedTab(id as AssignmentTargetType)}>
+          <TabNavigation
+            tabs={tabs}
+            activeTab={activeTab}
+            onTabChange={id => setPinnedTab(id as ServerAssignmentTargetType)}
+          >
             {active => (
-              <div className="p-[var(--spacing-system-mf)]">{renderTabBody(active as AssignmentTargetType)}</div>
+              <div className="p-[var(--spacing-system-mf)]">{renderTabBody(active as ServerAssignmentTargetType)}</div>
             )}
           </TabNavigation>
         )}
diff --git a/src/components/assignments/assignment-row.tsx b/src/components/assignments/assignment-row.tsx
index bdebbcea..9249092a 100644
--- a/src/components/assignments/assignment-row.tsx
+++ b/src/components/assignments/assignment-row.tsx
@@ -13,12 +13,14 @@ interface AssignmentRowProps {
   onChange: (next: AssignmentRef[]) => void;
   onRemoveRow: () => void;
   disabled?: boolean;
+  /** The picker cannot change the set — the row shows it, and the trash drops it. */
+  readOnly?: boolean;
 }
 
-export function AssignmentRow({ targetType, value, onChange, onRemoveRow, disabled }: AssignmentRowProps) {
+export function AssignmentRow({ targetType, value, onChange, onRemoveRow, disabled, readOnly }: AssignmentRowProps) {
   const meta = TARGET_CONFIG[targetType];
   const [searchInput, setSearchInput] = useState('');
-  const { options, isLoading } = useAssignmentSearch(targetType, searchInput);
+  const { options, isLoading } = useAssignmentSearch(targetType, searchInput, !readOnly);
 
   const selectedIds = useMemo(() => value.map(ref => ref.id), [value]);
 
@@ -59,7 +61,7 @@ export function AssignmentRow({ targetType, value, onChange, onRemoveRow, disabl
             placeholder="Add More..."
             loading={isLoading}
             disableClientFilter
-            disabled={disabled}
+            disabled={disabled || readOnly}
           />
         </div>
         <Button
diff --git a/src/components/assignments/assignments-field.tsx b/src/components/assignments/assignments-field.tsx
index 7f06e0c2..17df4ee7 100644
--- a/src/components/assignments/assignments-field.tsx
+++ b/src/components/assignments/assignments-field.tsx
@@ -5,7 +5,12 @@ import { ActionsMenuDropdown, Button } from '@flamingo-stack/openframe-frontend-
 import { useMemo } from 'react';
 import { AssignmentRow } from './assignment-row';
 import { TARGET_CONFIG } from './target-config';
-import { ASSIGNMENT_TARGET_TYPES, type AssignmentRef, type AssignmentsValue, type AssignmentTargetType } from './types';
+import {
+  ALL_ASSIGNMENT_TARGET_TYPES,
+  type AssignmentRef,
+  type AssignmentsValue,
+  type AssignmentTargetType,
+} from './types';
 
 interface AssignmentsFieldProps {
   value: AssignmentsValue;
@@ -20,13 +25,17 @@ const isPresent = (refs: AssignmentRef[] | undefined): refs is AssignmentRef[] =
 export function AssignmentsField({
   value,
   onChange,
-  enabledTypes = ASSIGNMENT_TARGET_TYPES as AssignmentTargetType[],
+  enabledTypes = ALL_ASSIGNMENT_TARGET_TYPES as AssignmentTargetType[],
   disabled,
   className,
 }: AssignmentsFieldProps) {
   const activeTypes = useMemo(() => enabledTypes.filter(type => isPresent(value[type])), [enabledTypes, value]);
 
-  const availableTypes = useMemo(() => enabledTypes.filter(type => !isPresent(value[type])), [enabledTypes, value]);
+  // Only pickable targets can be added by hand; the rest show up when the value carries them.
+  const availableTypes = useMemo(
+    () => enabledTypes.filter(type => TARGET_CONFIG[type].pickable && !isPresent(value[type])),
+    [enabledTypes, value],
+  );
 
   const setRow = (type: AssignmentTargetType, refs: AssignmentRef[]) => {
     onChange({ ...value, [type]: refs });
@@ -68,6 +77,7 @@ export function AssignmentsField({
             onChange={refs => setRow(type, refs)}
             onRemoveRow={() => removeRow(type)}
             disabled={disabled}
+            readOnly={!TARGET_CONFIG[type].pickable}
           />
         ))}
 
diff --git a/src/components/assignments/relay-id.ts b/src/components/assignments/relay-id.ts
index e452847e..ec7853f4 100644
--- a/src/components/assignments/relay-id.ts
+++ b/src/components/assignments/relay-id.ts
@@ -15,6 +15,7 @@ const RELAY_TYPE_NAME: Record<AssignmentItemType | AssignmentTargetType, string>
   DEVICE: 'Machine',
   TICKET: 'Ticket',
   KNOWLEDGE_ARTICLE: 'KnowledgeBaseItem',
+  INSIGHT: 'Insight',
 };
 
 const KNOWN_RELAY_TYPES: ReadonlySet<string> = new Set(Object.values(RELAY_TYPE_NAME));
diff --git a/src/components/assignments/schema.ts b/src/components/assignments/schema.ts
index 779ffff0..62471870 100644
--- a/src/components/assignments/schema.ts
+++ b/src/components/assignments/schema.ts
@@ -12,6 +12,7 @@ export const assignmentsSchema = z
     DEVICE: z.array(assignmentRefSchema).optional(),
     TICKET: z.array(assignmentRefSchema).optional(),
     KNOWLEDGE_ARTICLE: z.array(assignmentRefSchema).optional(),
+    INSIGHT: z.array(assignmentRefSchema).optional(),
   })
   .optional() satisfies z.ZodType<AssignmentsValue | undefined>;
 
diff --git a/src/components/assignments/target-config.ts b/src/components/assignments/target-config.ts
index 198eb244..52de24e7 100644
--- a/src/components/assignments/target-config.ts
+++ b/src/components/assignments/target-config.ts
@@ -1,4 +1,5 @@
 import {
+  AlertTriangleIcon,
   FileContentIcon,
   IdCardIcon,
   MonitorIcon,
@@ -18,6 +19,14 @@ export interface TargetMeta {
   menuLabel: string;
   tabLabel: string;
   icon: ComponentType<IconProps>;
+  /**
+   * The row can be added from the "Assign Item" menu and its picker searched.
+   * A UX flag, not "the server accepts it as a target" (that is
+   * `ASSIGNMENT_TARGET_TYPES`), even though the two coincide today: INSIGHT is
+   * not pickable because a ticket is linked to ONE incident by being filed from
+   * it, so the row only ever shows what the page arrived with (and can be dropped).
+   */
+  pickable: boolean;
 }
 
 export const TARGET_CONFIG: Record<AssignmentTargetType, TargetMeta> = {
@@ -26,13 +35,22 @@ export const TARGET_CONFIG: Record<AssignmentTargetType, TargetMeta> = {
     menuLabel: 'Customer',
     tabLabel: 'Customers',
     icon: IdCardIcon,
+    pickable: true,
   },
-  DEVICE: { rowLabel: 'Assigned Devices', menuLabel: 'Device', tabLabel: 'Devices', icon: MonitorIcon },
-  TICKET: { rowLabel: 'Assigned Tickets', menuLabel: 'Ticket', tabLabel: 'Tickets', icon: TagIcon },
+  DEVICE: { rowLabel: 'Assigned Devices', menuLabel: 'Device', tabLabel: 'Devices', icon: MonitorIcon, pickable: true },
+  TICKET: { rowLabel: 'Assigned Tickets', menuLabel: 'Ticket', tabLabel: 'Tickets', icon: TagIcon, pickable: true },
   KNOWLEDGE_ARTICLE: {
     rowLabel: 'Assigned Knowledge Articles',
     menuLabel: 'Knowledge Article',
     tabLabel: 'Knowledge Articles',
     icon: FileContentIcon,
+    pickable: true,
+  },
+  INSIGHT: {
+    rowLabel: 'Assigned Incident',
+    menuLabel: 'Incident',
+    tabLabel: 'Incidents',
+    icon: AlertTriangleIcon,
+    pickable: false,
   },
 };
diff --git a/src/components/assignments/types.ts b/src/components/assignments/types.ts
index a5edeee5..76f9cd87 100644
--- a/src/components/assignments/types.ts
+++ b/src/components/assignments/types.ts
@@ -1,6 +1,19 @@
-export type AssignmentTargetType = 'ORGANIZATION' | 'DEVICE' | 'TICKET' | 'KNOWLEDGE_ARTICLE';
+/** The server's `AssignmentTargetType` — what `assignedItems` is queried for and `assignItem` accepts. */
+export type ServerAssignmentTargetType = 'ORGANIZATION' | 'DEVICE' | 'TICKET' | 'KNOWLEDGE_ARTICLE';
 
-export type AssignmentItemType = 'TICKET' | 'KNOWLEDGE_ARTICLE';
+/**
+ * What an item can be assigned TO, as a form may render it. INSIGHT is
+ * client-only — the server links a ticket to the incident it is filed from in
+ * the other direction (item INSIGHT → target TICKET, via
+ * `CreateTicketInput.insightId`), so on the ticket form the incident is a row
+ * that is shown and sent as `insightId`, never assigned through `assignItem`.
+ * Hence `ASSIGNMENT_TARGET_TYPES` (the server list) vs
+ * `ALL_ASSIGNMENT_TARGET_TYPES` (what a form may render).
+ */
+export type AssignmentTargetType = ServerAssignmentTargetType | 'INSIGHT';
+
+/** What can own assignments — the server's `AssignmentItemType`. */
+export type AssignmentItemType = 'TICKET' | 'KNOWLEDGE_ARTICLE' | 'INSIGHT';
 
 export interface AssignmentRef {
   id: string;
@@ -9,9 +22,13 @@ export interface AssignmentRef {
 
 export type AssignmentsValue = Partial<Record<AssignmentTargetType, AssignmentRef[]>>;
 
-export const ASSIGNMENT_TARGET_TYPES: ReadonlyArray<AssignmentTargetType> = [
+/** The targets the server reads and writes — what `assignedItems` is queried for and `assignItem` accepts. */
+export const ASSIGNMENT_TARGET_TYPES: ReadonlyArray<ServerAssignmentTargetType> = [
   'ORGANIZATION',
   'DEVICE',
   'TICKET',
   'KNOWLEDGE_ARTICLE',
 ];
+
+/** Every target a form may render, the client-only INSIGHT included. */
+export const ALL_ASSIGNMENT_TARGET_TYPES: ReadonlyArray<AssignmentTargetType> = [...ASSIGNMENT_TARGET_TYPES, 'INSIGHT'];
diff --git a/src/components/assignments/use-assigned-items.ts b/src/components/assignments/use-assigned-items.ts
index 02580048..e8aa1257 100644
--- a/src/components/assignments/use-assigned-items.ts
+++ b/src/components/assignments/use-assigned-items.ts
@@ -7,6 +7,7 @@ import { getDeviceName } from '@/app/(app)/devices/utils/device-name';
 import { type DeviceRowFields, rowFieldsToDevice } from '@/app/(app)/devices/utils/device-transform';
 import type { KnowledgeBaseRow } from '@/app/(app)/knowledge-base/components/knowledge-base-table-columns';
 import type { Dialog, DialogStatus } from '@/app/(app)/tickets/types/dialog.types';
+import { decodeGlobalId } from '@/lib/relay-id';
 import { postGraphQl } from './graphql';
 import { ensureGlobalId } from './relay-id';
 import {
@@ -14,7 +15,7 @@ import {
   type AssignmentItemType,
   type AssignmentRef,
   type AssignmentsValue,
-  type AssignmentTargetType,
+  type ServerAssignmentTargetType,
 } from './types';
 
 const ASSIGNED_ITEMS_QUERY = `#graphql
@@ -144,8 +145,13 @@ function toMachineRowFields(target: AssignedTargetNode): DeviceRowFields {
 
 function toDialog(target: AssignedTargetNode): Dialog {
   const t = unaliasFields(target);
+  // api-service-core hands every AssignableTarget a global id, while the ticket
+  // pages key on the raw one — a global id in `/tickets/dialog?id=` is "ticket
+  // not found". Guarded on the typename: a raw 24-hex ObjectId is valid base64
+  // too, and an unguarded decode would mangle the few that contain a colon byte.
+  const decoded = decodeGlobalId(target.id);
   return {
-    id: target.id,
+    id: decoded?.typename === 'Ticket' ? decoded.rawId : target.id,
     title: (t.title as string) || 'Untitled Dialog',
     status: ((t.status as string) ?? 'ACTIVE') as DialogStatus,
     owner: { type: 'CLIENT' },
@@ -171,7 +177,10 @@ interface AssignedItemsPayload {
   tickets?: Dialog[];
 }
 
-async function fetchAssignedItems(itemId: string, targetType: AssignmentTargetType): Promise<AssignedItemsPayload> {
+async function fetchAssignedItems(
+  itemId: string,
+  targetType: ServerAssignmentTargetType,
+): Promise<AssignedItemsPayload> {
   const data = await postGraphQl<AssignedItemsData>(ASSIGNED_ITEMS_QUERY, {
     itemId,
     targetType,
@@ -222,8 +231,8 @@ async function fetchAssignedItems(itemId: string, targetType: AssignmentTargetTy
       return { refs, tickets };
     default: {
       // `targetType` is `never` here because the cases above cover
-      // AssignmentTargetType. A new member of that union fails to compile rather
-      // than resolving the query with `undefined`.
+      // ServerAssignmentTargetType. A new member of that union fails to compile
+      // rather than resolving the query with `undefined`.
       const unreachable: never = targetType;
       return unreachable;
     }
diff --git a/src/components/assignments/use-assignment-search.ts b/src/components/assignments/use-assignment-search.ts
index ebaf3f72..0ce5d6c4 100644
--- a/src/components/assignments/use-assignment-search.ts
+++ b/src/components/assignments/use-assignment-search.ts
@@ -101,6 +101,7 @@ const EMPTY_OPTIONS: AssignmentSearchOption[] = [];
 function useServerSearchOptions(
   targetType: AssignmentTargetType,
   search: string,
+  enabled: boolean,
 ): { options: AssignmentSearchOption[]; isLoading: boolean } {
   const debouncedSearch = useDebounce(search, 300);
   const fetcher = SERVER_SEARCH_FETCHERS[targetType];
@@ -108,7 +109,7 @@ function useServerSearchOptions(
   // (the API takes no status enum), so it waits for the status snapshot —
   // cached and shared with the tickets pages.
   const isTicket = targetType === 'TICKET';
-  const statusesQuery = useTicketStatusesQuery({ enabled: isTicket });
+  const statusesQuery = useTicketStatusesQuery({ enabled: enabled && isTicket });
   const nonArchivedStatusIds = useMemo(
     () => statusesQuery.data?.snapshot.filter(s => s.kind !== TICKET_STATUS_KIND.ARCHIVED).map(s => s.id),
     [statusesQuery.data],
@@ -119,7 +120,7 @@ function useServerSearchOptions(
       if (isTicket) return fetchTickets(debouncedSearch, nonArchivedStatusIds ?? []);
       return fetcher ? fetcher(debouncedSearch) : Promise.resolve(EMPTY_OPTIONS);
     },
-    enabled: isTicket ? !!nonArchivedStatusIds?.length : !!fetcher,
+    enabled: enabled && (isTicket ? !!nonArchivedStatusIds?.length : !!fetcher),
     staleTime: 30_000,
   });
   return {
@@ -128,11 +129,15 @@ function useServerSearchOptions(
   };
 }
 
-function useKnowledgeArticleOptions(search: string): { options: AssignmentSearchOption[]; isLoading: boolean } {
+function useKnowledgeArticleOptions(
+  search: string,
+  enabled: boolean,
+): { options: AssignmentSearchOption[]; isLoading: boolean } {
   const query = useQuery({
     queryKey: ['assignments', 'search', 'KNOWLEDGE_ARTICLE'],
     queryFn: fetchKnowledgeArticles,
     staleTime: 30_000,
+    enabled,
   });
   const debouncedSearch = useDebounce(search, 300);
   const options = useMemo(() => {
@@ -144,11 +149,13 @@ function useKnowledgeArticleOptions(search: string): { options: AssignmentSearch
   return { options, isLoading: query.isLoading };
 }
 
+/** `enabled` false keeps every request off — a read-only row has nothing to search. */
 export function useAssignmentSearch(
   targetType: AssignmentTargetType,
   search: string,
+  enabled = true,
 ): { options: AssignmentSearchOption[]; isLoading: boolean } {
-  const articleResult = useKnowledgeArticleOptions(search);
-  const serverResult = useServerSearchOptions(targetType, search);
+  const articleResult = useKnowledgeArticleOptions(search, enabled);
+  const serverResult = useServerSearchOptions(targetType, search, enabled);
   return targetType === 'KNOWLEDGE_ARTICLE' ? articleResult : serverResult;
 }
diff --git a/src/graphql/insights/incident-detail-relay.ts b/src/graphql/insights/incident-detail-relay.ts
index f1077198..a953160d 100644
--- a/src/graphql/insights/incident-detail-relay.ts
+++ b/src/graphql/insights/incident-detail-relay.ts
@@ -9,5 +9,6 @@ export const incidentDetailRelayQuery = graphql`
     insight(id: $id) {
       ...insightFields_insight
     }
+    ...insightTransitions_query
   }
 `;
diff --git a/src/graphql/insights/incidents-table-relay.ts b/src/graphql/insights/incidents-table-relay.ts
index c15ef35e..5fbb4049 100644
--- a/src/graphql/insights/incidents-table-relay.ts
+++ b/src/graphql/insights/incidents-table-relay.ts
@@ -17,6 +17,7 @@ export const incidentsTableRelayQuery = graphql`
     insightFilters(filter: $filter, search: $search) {
       ...insightFacets_filters
     }
+    ...insightTransitions_query
   }
 `;
 
diff --git a/src/graphql/insights/insight-chat-prompt-relay.ts b/src/graphql/insights/insight-chat-prompt-relay.ts
new file mode 100644
index 00000000..e07deb09
--- /dev/null
+++ b/src/graphql/insights/insight-chat-prompt-relay.ts
@@ -0,0 +1,13 @@
+import { graphql } from 'react-relay';
+
+/**
+ * "Fix with Mingo": the message the server wants dropped into a new chat about
+ * this insight — the `@insight:` / `@device:` markers plus a short ask. Fetched
+ * on click (`fetchQuery`), not rendered from the row: the marker carries the
+ * STORED insight id and the ask is the server's, so neither can go stale here.
+ */
+export const insightChatPromptRelayQuery = graphql`
+  query insightChatPromptRelayQuery($id: ID!) {
+    insightChatPrompt(id: $id)
+  }
+`;
diff --git a/src/graphql/insights/insight-transitions.ts b/src/graphql/insights/insight-transitions.ts
new file mode 100644
index 00000000..0e222a75
--- /dev/null
+++ b/src/graphql/insights/insight-transitions.ts
@@ -0,0 +1,17 @@
+import { graphql } from 'react-relay';
+
+/**
+ * The status-transition table the mutations enforce, so the row menu and the
+ * detail header offer exactly what the server will accept instead of restating
+ * the rules (which drifted once already). Spread in the list and detail
+ * queries — one extra field on a request already in flight, no round trip —
+ * and read by `toTransitionTable`, a plain function, hence `@inline`.
+ */
+export const insightTransitionsFragment = graphql`
+  fragment insightTransitions_query on Query @inline {
+    insightStatusTransitions {
+      from
+      to
+    }
+  }
+`;
diff --git a/src/lib/relay-id.ts b/src/lib/relay-id.ts
index 0464fb71..aefec6a9 100644
--- a/src/lib/relay-id.ts
+++ b/src/lib/relay-id.ts
@@ -54,6 +54,11 @@ export function ensureGlobalIdForType(typename: string, value: string): string {
   return toGlobalId(typename, value);
 }
 
+/** The id INSIDE a global handle; a value that is not one comes back as is. */
+export function rawIdOf(value: string): string {
+  return decodeGlobalId(value)?.rawId ?? value;
+}
+
 export function notificationGlobalId(rawId: string): string {
   return ensureGlobalIdForType('Notification', rawId);
 }
diff --git a/src/lib/routes.ts b/src/lib/routes.ts
index 27d6c55c..b5b95357 100644
--- a/src/lib/routes.ts
+++ b/src/lib/routes.ts
@@ -87,6 +87,8 @@ export type HelpCenterLegalDoc = 'privacy' | 'terms';
  * cannot be added to one and silently dropped by another. Ids are the raw ones
  * the form's pickers use (`Organization.organizationId`, `Machine.machineId`,
  * `User.id`); the names label those picks before the option lists have loaded.
+ * `insightId` is the STORED insight id (`CreateTicketInput.insightId`), which
+ * links the ticket to the incident it is filed from; `insightTitle` labels it.
  */
 export const TICKET_PREFILL_KEYS = [
   'title',
@@ -97,6 +99,8 @@ export const TICKET_PREFILL_KEYS = [
   'deviceName',
   'assigneeId',
   'assigneeName',
+  'insightId',
+  'insightTitle',
 ] as const;
 
 export type TicketPrefill = Partial<Record<(typeof TICKET_PREFILL_KEYS)[number], string>>;