@sanity/workflow-studio-plugin 0.27.0 → 0.29.0

package/dist/_chunks-es/workflows-tool-root.js

@@ -8,22 +8,28 @@ import { useState, useEffect, useMemo, useRef, useSyncExternalStore, useCallback
 
 import { useRouter } from "sanity/router";
 
-import { isLiveEntry, AbortWorkflowDialog, isEvaluationStale, useSpaceToken, DocPreviewLink, SpinnerSlot, useWorkflowInstanceEntry, useLogEventOnMount, WorkflowInstanceDetailViewed, LoadingRow, InvalidDocNotice, useDefinition, useContainerToken, openActivityGone, InstanceSnapshotBody, ActivityLog, ActivityDetailDialog, instanceBreadcrumb, CodeChip, instanceTitle, namesNoDeployedDefinition, mappingIssueDetail, formatTimeAgo, formatShortDateTime, useWorkflowContext, readDeployedDefinitions, describeError, EmptyState, CautionNote, HoverHint, DismissablePopover, createSubscribers, useDelayedFlag, definitionSnapshotOf, findActivity, stageTitle, stateByActivity, findActivityNode, rowDateControlState, rowAssignControlState, isActivityAssignedTo, assigneesOf, dueDatesOf, datesOf, isOpenActivityStatus, committedRowFace, activityRowProps, gdrLocality, TOAST_ID, WORKFLOW_API_VERSION, useWorkflowToast, openableSchemaType, formatDate, parseStoredDateValue, useUserDisplays, useProjectMembers, WorkflowTaskFiltersApplied, DocRefFace, Hairline, LinkChip, BreadcrumbTail, StageFace, StaleLock, ActivityRow, WorkflowTitleSeedDrifted, UnreadableDocsNote, ForMeEmptyState, useBadgeCapTrim, CountedLabel, MetaRow, TabSwitch, WORKFLOW_PAGE_TABS, definitionFingerprint, LogEventOnMount, WorkflowBoardWorkflowSelected, WorkflowDefinitionDetailViewed, toolRoute, landingState, TOOL_TABS, tabSelectionNavigates, WorkflowToolOpened, toolTabState, workflowPageState, instanceState, backToTabLabel, useAssignmentIdentity, workflowState } from "./index.js";
+import { isLiveEntry, AbortWorkflowDialog, useSpaceToken, isEvaluationStale, DocPreviewLink, SpinnerSlot, useWorkflowInstanceEntry, useLogEventOnMount, WorkflowInstanceDetailViewed, LoadingRow, InvalidDocNotice, useDefinition, useContainerToken, openActivityGone, InstanceFaultNote, InstanceSnapshotBody, ActivityLog, ActivityDetailDialog, instanceBreadcrumb, CodeChip, instanceTitle, dueDatesOf, isDueDatePast, isOpenActivityStatus, definitionSnapshotOf, stageTitle, isActivityAssignedTo, namesNoDeployedDefinition, mappingIssueDetail, formatTimeAgo, formatShortDateTime, useWorkflowContext, readDeployedDefinitions, describeError, gdrLocality, openableSchemaType, identityOf, useMinuteClock, NoteBanner, EmptyState, CountedHeading, AlertGlyph, MetricPair, formatShortAgo, InlineEmphasis, DismissablePopover, createSubscribers, findActivity, stateByActivity, rowDateControlState, rowAssignControlState, isRoleAssignedTo, assigneesOf, datesOf, committedRowFace, activityRowProps, TOAST_ID, WORKFLOW_API_VERSION, useWorkflowToast, formatDate, parseStoredDateValue, useUserDisplays, useProjectMembers, HoverHint, WorkflowTaskFiltersApplied, DocRefFace, Hairline, LinkChip, BreadcrumbTail, StageFace, StaleLock, ActivityRow, WorkflowTitleSeedDrifted, UnreadableDocsNote, RoleAssignedNotice, ForMeEmptyState, MetaRow, TabSwitch, WORKFLOW_PAGE_TABS, definitionFingerprint, LogEventOnMount, WorkflowBoardWorkflowSelected, WorkflowDefinitionDetailViewed, toolRoute, landingState, TOOL_TABS, tabSelectionNavigates, WorkflowToolOpened, toolTabState, workflowPageState, instanceState, backToTabLabel, useAssignmentIdentity, workflowState } from "./index.js";
 
-import { entryDocRefs, startKindOf, isSubjectEntry, isInputSourced, latestDeployedDefinitions, terminalState, isStartableDefinition, toBareId, findOpenStageEntry } from "@sanity/workflow-engine";
+import { entryDocRefs, toBareId, findOpenStageEntry, terminalState, documentStuckCause, startKindOf, isSubjectEntry, isInputSourced, errorMessage, latestDeployedDefinitions, isStartableDefinition, findActivityNode } from "@sanity/workflow-engine";
 
 import { ArrowLeftIcon } from "@sanity/icons/ArrowLeft";
 
-import { TransferIcon } from "@sanity/icons/Transfer";
+import { CalendarIcon } from "@sanity/icons/Calendar";
 
-import { WarningOutlineIcon } from "@sanity/icons/WarningOutline";
+import { ClockIcon } from "@sanity/icons/Clock";
 
-import pluralize from "pluralize-esm";
+import { DocumentIcon } from "@sanity/icons/Document";
 
-import { useSchema, useClient, useDocumentPreviewStore, usePerspective } from "sanity";
+import { ErrorOutlineIcon } from "@sanity/icons/ErrorOutline";
+
+import { TransferIcon } from "@sanity/icons/Transfer";
+
+import { useDocumentPreviewStore, useSchema, usePerspective, useClient } from "sanity";
 
 import { useWorkflowInstances } from "@sanity/workflow-studio";
 
+import pluralize from "pluralize-esm";
+
 import { AddIcon } from "@sanity/icons/Add";
 
 import { SearchIcon } from "@sanity/icons/Search";
@@ -46,6 +52,10 @@ import { ChevronRightIcon } from "@sanity/icons/ChevronRight";
 
 import { isReferenceSchemaType } from "@sanity/types";
 
+import { EmptyIcon } from "@sanity/icons/Empty";
+
+import { WarningOutlineIcon } from "@sanity/icons/WarningOutline";
+
 import { WorkflowDiagram } from "@sanity/workflow-diagram";
 
 import { useReducedMotion, motion, useSpring, useMotionValueEvent } from "motion/react";
@@ -89,11 +99,22 @@ function documentRefsOf(instance) {
     return [ ...seen.values() ];
 }
 
+function rootInstanceOf(instance, byId) {
+    const rootRef = instance.ancestors[0];
+    return rootRef ? byId.get(toBareId(rootRef.id)) ?? instance : instance;
+}
+
+const TOOL_PANEL_PADDING = 3, TOOL_HEADING_PADDING = 2, PANEL_STEP = 3;
+
 function TabStatusRow({children: children}) {
+    const firstLineOffset = useSpaceToken(PANEL_STEP) + useSpaceToken(TOOL_HEADING_PADDING);
     /* @__PURE__ */
     return jsx(Box, {
-        paddingLeft: 2,
-        paddingY: 3,
+        paddingBottom: PANEL_STEP,
+        paddingLeft: TOOL_HEADING_PADDING,
+        style: {
+            paddingTop: firstLineOffset
+        },
         children: children
     });
 }
@@ -344,14 +365,24 @@ function InstanceDetailBody({entry: entry, framed: framed, subject: subject}) {
                 },
                 children: /* @__PURE__ */ jsxs(Stack, {
                     gap: 5,
-                    children: [ subject === "preview" ? /* @__PURE__ */ jsx(SubjectPreview, {
+                    children: [ 
+                    /* @__PURE__ */ jsx(InstanceFaultNote, {
+                        entry: entry,
+                        scope: {
+                            kind: "run",
+                            onOpenActivity: activityName => setOpenActivity({
+                                stage: instance.currentStage,
+                                activityName: activityName
+                            })
+                        }
+                    }), subject === "preview" ? /* @__PURE__ */ jsx(SubjectPreview, {
                         instance: instance
                     }) : null, 
                     /* @__PURE__ */ jsxs(Stack, {
                         gap: 4,
                         children: [ 
                         /* @__PURE__ */ jsx(SectionHeading, {
-                            children: "Stages / Tasks"
+                            children: "Stages"
                         }), 
                         /* @__PURE__ */ jsx(InstanceSnapshotBody, {
                             entry: entry,
@@ -433,12 +464,140 @@ function byResolvedTitle(titleOf, keyOf) {
     };
 }
 
+function openActivitiesOf(instance) {
+    return (findOpenStageEntry(instance)?.activities ?? []).filter(activity => isOpenActivityStatus(activity.status));
+}
+
+function overdueTaskCount(instance, now) {
+    return openActivitiesOf(instance).filter(activity => dueDatesOf(activity.fields ?? []).some(due => isDueDatePast(due, now))).length;
+}
+
+const NO_SIGNALS = {
+    activeCount: 0,
+    assignedToMe: 0,
+    documentCount: 0,
+    documentlessCount: 0,
+    initialStageDocumentCount: 0,
+    lastTransition: void 0,
+    overdueDocumentCount: 0,
+    overdueDocumentlessCount: 0,
+    stuckCount: 0
+};
+
+function noDefinitionSignals() {
+    return NO_SIGNALS;
+}
+
+function holdsWorkFor(instance, who) {
+    return openActivitiesOf(instance).some(activity => isActivityAssignedTo({
+        state: activity.fields ?? [],
+        who: who
+    }));
+}
+
+function arrivalOf(instance, byId) {
+    const stage = findOpenStageEntry(instance);
+    if (stage !== void 0) return {
+        at: stage.enteredAt,
+        document: documentRefOf(instance, byId),
+        stage: stageTitle(definitionSnapshotOf(instance), stage.name)
+    };
+}
+
+function laterArrival(held, next) {
+    return next === void 0 ? held : held === void 0 || next.at > held.at ? next : held;
+}
+
+function documentRefOf(instance, byId) {
+    return documentRefsOf(rootInstanceOf(instance, byId))[0];
+}
+
+const NO_DRAFT = {
+    ...NO_SIGNALS,
+    documents: /* @__PURE__ */ new Set,
+    initialStageDocuments: /* @__PURE__ */ new Set,
+    overdueDocuments: /* @__PURE__ */ new Set
+};
+
+function withDocument(held, document2) {
+    return document2 === void 0 ? held : new Set(held).add(document2);
+}
+
+function atInitialStage(instance) {
+    const snapshot = definitionSnapshotOf(instance);
+    return snapshot !== void 0 && instance.currentStage === snapshot.initialStage;
+}
+
+function fold(args) {
+    const {byId: byId, held: held, instance: instance, now: now, who: who} = args, stuck = documentStuckCause({
+        instance: instance,
+        definition: definitionSnapshotOf(instance)
+    }), document2 = documentRefOf(instance, byId)?.id, overdue = overdueTaskCount(instance, now) > 0;
+    return {
+        activeCount: held.activeCount + 1,
+        assignedToMe: held.assignedToMe + (who !== void 0 && holdsWorkFor(instance, who) ? 1 : 0),
+        documentlessCount: held.documentlessCount + (document2 === void 0 ? 1 : 0),
+        documents: withDocument(held.documents, document2),
+        initialStageDocuments: atInitialStage(instance) ? withDocument(held.initialStageDocuments, document2) : held.initialStageDocuments,
+        lastTransition: laterArrival(held.lastTransition, arrivalOf(instance, byId)),
+        overdueDocumentlessCount: held.overdueDocumentlessCount + (overdue && document2 === void 0 ? 1 : 0),
+        overdueDocuments: overdue ? withDocument(held.overdueDocuments, document2) : held.overdueDocuments,
+        stuckCount: held.stuckCount + (stuck === void 0 ? 0 : 1)
+    };
+}
+
+function settle(draft) {
+    const {documents: documents, initialStageDocuments: initialStageDocuments, overdueDocuments: overdueDocuments, ...rest} = draft;
+    return {
+        ...rest,
+        documentCount: documents.size,
+        initialStageDocumentCount: initialStageDocuments.size,
+        overdueDocumentCount: overdueDocuments.size
+    };
+}
+
+function definitionSignals(args) {
+    const byId = new Map(args.instances.map(instance => [ instance._id, instance ])), drafts = /* @__PURE__ */ new Map;
+    for (const instance of args.instances) {
+        if (terminalState(instance) !== "in-flight") continue;
+        const held = drafts.get(instance.definition) ?? NO_DRAFT;
+        drafts.set(instance.definition, fold({
+            byId: byId,
+            held: held,
+            instance: instance,
+            now: args.now,
+            who: args.identity
+        }));
+    }
+    return new Map([ ...drafts ].map(([name, draft]) => [ name, settle(draft) ]));
+}
+
+function catalogBands(rows) {
+    const assigned = rows.filter(row => row.signals.assignedToMe > 0);
+    if (assigned.length === 0) return [ {
+        rows: rows,
+        title: void 0
+    } ];
+    const rest = rows.filter(row => row.signals.assignedToMe === 0);
+    return [ {
+        rows: assigned,
+        title: "Assigned to you"
+    }, {
+        rows: rest,
+        title: "Other workflows"
+    } ].filter(band => band.rows.length > 0);
+}
+
 function definitionCatalog(args) {
-    const rejected = [ ...args.issues.values() ];
+    const rejected = [ ...args.issues.values() ], signals = definitionSignals({
+        identity: args.identity,
+        instances: args.instances,
+        now: args.now
+    });
     return args.definitions.map(definition => ({
         name: definition.name,
         title: definition.title ?? definition.name,
-        activeCount: args.inFlight.filter(instance => instance.definition === definition.name).length,
+        signals: signals.get(definition.name) ?? noDefinitionSignals(),
         docTypes: [ ...new Set(args.mappings.filter(mapping => mapping.definition === definition.name).map(mapping => mapping.docType)) ],
         brokenBindings: rejected.filter(issue => issue.definition === definition.name && issue.version === definition.version).map(issue => ({
             docType: issue.docType,
@@ -476,28 +635,60 @@ function deployedPhrase(definition) {
     return ago === "" ? formatShortDateTime(deployedAt) : `${formatShortDateTime(deployedAt)} (${ago})`;
 }
 
-const TOOL_PANEL_PADDING = 3, TOOL_HEADING_PADDING = 2;
+const logged = /* @__PURE__ */ new WeakSet;
 
-function catalogReadError(error) {
-    return `Could not load the deployed workflows: ${error}`;
+function logReadFailure(what, error) {
+    if (typeof error == "object" && error !== null) {
+        if (logged.has(error)) return;
+        logged.add(error);
+    }
+    console.error(`[workflow-studio-plugin] could not load ${what}:`, error);
+}
+
+function useReadFailureLog(what, error) {
+    useEffect(() => {
+        error !== void 0 && logReadFailure(what, error);
+    }, [ what, error ]);
+}
+
+const INSTANCE_CAP = 200, INSTANCES_READ_FAILED = "Couldn’t load workflow data. Try again later.";
+
+function useCappedInstances(filter) {
+    const {engine: engine} = useWorkflowContext(), capped = useMemo(() => ({
+        ...filter,
+        limit: INSTANCE_CAP
+    }), [ filter ]), {instances: instances, loading: loading, unreadable: unreadable, error: error} = useWorkflowInstances({
+        engine: engine,
+        filter: capped
+    });
+    return useReadFailureLog("workflow data", error), useMemo(() => {
+        const rows = instances ?? [];
+        return {
+            rows: rows,
+            truncated: rows.length + unreadable.length === INSTANCE_CAP,
+            loading: loading,
+            unreadable: unreadable,
+            error: error === void 0 ? void 0 : errorMessage(error)
+        };
+    }, [ instances, loading, unreadable, error ]);
 }
 
-const lastRead = /* @__PURE__ */ new WeakMap, issuedReads = /* @__PURE__ */ new WeakMap;
+const CATALOG_READ_FAILED = "Couldn’t load the deployed workflows. Try again later.", lastRead$1 = /* @__PURE__ */ new WeakMap, issuedReads = /* @__PURE__ */ new WeakMap;
 
 function useDeployedDefinitions() {
-    const {engine: engine} = useWorkflowContext(), [definitions, setDefinitions] = useState(() => lastRead.get(engine)?.rows), [error, setError] = useState(void 0);
+    const {engine: engine} = useWorkflowContext(), [definitions, setDefinitions] = useState(() => lastRead$1.get(engine)?.rows), [error, setError] = useState(void 0);
     return useEffect(() => {
         let cancelled = !1;
-        setDefinitions(lastRead.get(engine)?.rows), setError(void 0);
+        setDefinitions(lastRead$1.get(engine)?.rows), setError(void 0);
         const seq = (issuedReads.get(engine) ?? 0) + 1;
         return issuedReads.set(engine, seq), (async () => {
-            const rows = await readDeployedDefinitions(engine), latest = latestDeployedDefinitions(rows), held = lastRead.get(engine);
-            (held === void 0 || seq > held.seq) && lastRead.set(engine, {
+            const rows = await readDeployedDefinitions(engine), latest = latestDeployedDefinitions(rows), held = lastRead$1.get(engine);
+            (held === void 0 || seq > held.seq) && lastRead$1.set(engine, {
                 seq: seq,
                 rows: latest
             }), cancelled || (setDefinitions(latest), setError(void 0));
         })().catch(err => {
-            cancelled || setError(describeError(err));
+            logReadFailure("the deployed workflows", err), cancelled || setError(describeError(err));
         }), () => {
             cancelled = !0;
         };
@@ -507,75 +698,197 @@ function useDeployedDefinitions() {
     };
 }
 
-const INSTANCE_CAP = 200;
+const NO_TITLES = {
+    titles: /* @__PURE__ */ new Map,
+    resolved: /* @__PURE__ */ new Set
+};
 
-function useCappedInstances(filter) {
-    const {engine: engine} = useWorkflowContext(), capped = useMemo(() => ({
-        ...filter,
-        limit: INSTANCE_CAP
-    }), [ filter ]), {instances: instances, loading: loading, unreadable: unreadable} = useWorkflowInstances({
-        engine: engine,
-        filter: capped
-    });
-    return useMemo(() => {
-        const rows = instances ?? [];
-        return {
-            rows: rows,
-            truncated: rows.length + unreadable.length === INSTANCE_CAP,
-            loading: loading,
-            unreadable: unreadable
+function useDocPreviewTitles(documents) {
+    const previewStore = useDocumentPreviewStore(), schema = useSchema(), {perspectiveStack: perspectiveStack} = usePerspective(), {actualTypes: actualTypes, binding: binding} = useWorkflowContext(), [state, setState] = useState(NO_TITLES), key = documents.map(doc => doc.id).join("|");
+    return useEffect(() => {
+        const titles = /* @__PURE__ */ new Map, resolved = /* @__PURE__ */ new Set, previews = /* @__PURE__ */ new Map, publish = () => setState({
+            titles: new Map(titles),
+            resolved: new Set(resolved)
+        }), localDocs = documents.flatMap(doc => {
+            const {parsed: parsed, local: local} = gdrLocality(doc.id, binding.contentResource);
+            return !parsed || !local ? (resolved.add(doc.id), []) : [ {
+                doc: doc,
+                bareId: parsed.documentId
+            } ];
+        }), untracks = localDocs.map(({bareId: bareId}) => actualTypes.track(bareId)), dropPreview = docId => {
+            previews.get(docId)?.unsubscribe(), previews.delete(docId), titles.delete(docId);
+        }, observe = ({docId: docId, bareId: bareId, typeName: typeName}) => {
+            const schemaType = openableSchemaType(schema, typeName);
+            if (!schemaType) return !1;
+            if (previews.get(docId)?.typeName === typeName) return !0;
+            dropPreview(docId), resolved.delete(docId);
+            const subscription = previewStore.observeForPreview({
+                _id: bareId,
+                _type: schemaType.name
+            }, schemaType, {
+                perspective: perspectiveStack
+            }).subscribe({
+                next: event => {
+                    resolved.add(docId);
+                    const title = event.snapshot?.title;
+                    typeof title == "string" ? titles.set(docId, title) : titles.delete(docId), publish();
+                },
+                error: err => {
+                    console.error(`[workflow-studio-plugin] preview for "${docId}" failed:`, err), resolved.add(docId), 
+                    publish();
+                }
+            });
+            return previews.set(docId, {
+                typeName: typeName,
+                unsubscribe: () => subscription.unsubscribe()
+            }), !0;
+        }, evaluate = () => {
+            for (const {doc: doc, bareId: bareId} of localDocs) {
+                const probe = actualTypes.read(bareId);
+                if (probe === null) {
+                    dropPreview(doc.id), resolved.add(doc.id);
+                    continue;
+                }
+                !observe({
+                    docId: doc.id,
+                    bareId: bareId,
+                    typeName: probe ?? doc.type
+                }) && typeof probe == "string" && (dropPreview(doc.id), resolved.add(doc.id));
+            }
+            publish();
+        }, unsubscribeProbes = actualTypes.subscribe(evaluate);
+        return evaluate(), () => {
+            unsubscribeProbes(), untracks.forEach(untrack => untrack()), previews.forEach(preview => preview.unsubscribe());
         };
-    }, [ instances, loading, unreadable ]);
+    }, [ key, previewStore, schema, actualTypes, binding.contentResource.id, perspectiveStack.join("|") ]), 
+    state;
 }
 
 const INSTANCE_CAP_COUNT_NOTE = `Counts from the latest ${INSTANCE_CAP} workflows — older ones aren’t counted.`, NEWEST_INSTANCES = {
     includeCompleted: !0
-};
+}, lastRead = /* @__PURE__ */ new WeakMap;
 
 function useToolInstances() {
-    const {rows: rows, truncated: truncated, loading: loading, unreadable: unreadable} = useCappedInstances(NEWEST_INSTANCES);
-    return useMemo(() => ({
+    const {engine: engine} = useWorkflowContext(), {rows: rows, truncated: truncated, loading: loading, unreadable: unreadable, error: error} = useCappedInstances(NEWEST_INSTANCES), fresh = useMemo(() => ({
         inFlight: rows.filter(instance => terminalState(instance) === "in-flight"),
         settled: rows.filter(instance => terminalState(instance) !== "in-flight"),
         truncated: truncated,
         loading: loading,
-        unreadable: unreadable
-    }), [ rows, truncated, loading, unreadable ]);
+        unreadable: unreadable,
+        error: error
+    }), [ rows, truncated, loading, unreadable, error ]);
+    return useEffect(() => {
+        !fresh.loading && fresh.error === void 0 && lastRead.set(engine, fresh);
+    }, [ engine, fresh ]), loading ? lastRead.get(engine) ?? fresh : fresh;
+}
+
+function documentPhrase(count) {
+    return count === 0 ? "No documents" : pluralize("document", count, !0);
+}
+
+function documentlessTail(count) {
+    return count === 0 ? "" : ` (${pluralize("instance", count, !0)})`;
+}
+
+function documentlessNote(work) {
+    return work.documentCount > 0 ? "" : documentlessTail(work.documentlessCount);
+}
+
+function documentFace(work, atStart) {
+    const lead = `${documentPhrase(work.documentCount)} with an active workflow${documentlessNote(work)}`;
+    return atStart === 0 ? {
+        lead: lead,
+        startLine: void 0
+    } : atStart === work.documentCount ? {
+        lead: `${lead}, yet to leave the starting stage`,
+        startLine: void 0
+    } : {
+        lead: lead,
+        startLine: `${atStart} still at the starting stage`
+    };
+}
+
+function overdueHint(work) {
+    return `${documentPhrase(work.documentCount)} with overdue tasks${documentlessTail(work.documentlessCount)}`;
+}
+
+const UNTITLED_DOCUMENT = "Untitled", TRANSITION_HINT_PENDING = "Loading…";
+
+function transitionHeading(at) {
+    return `Last stage change at ${formatShortDateTime(at)}`;
+}
+
+function transitionFace(args) {
+    return args.documentPending ? {
+        state: "pending"
+    } : {
+        state: "ready",
+        document: args.documentTitle,
+        heading: transitionHeading(args.at),
+        lead: args.documentTitle === void 0 ? "Changed to" : "changed to",
+        stage: args.stage
+    };
+}
+
+function catalogView(args) {
+    if (args.error !== void 0) return {
+        kind: "unreadable"
+    };
+    if (args.definitions === void 0 || args.instances.loading || args.identity.kind === "pending") return {
+        kind: "loading"
+    };
+    if (args.definitions.length === 0) return {
+        kind: "empty"
+    };
+    const rows = definitionCatalog({
+        definitions: args.definitions,
+        identity: identityOf(args.identity),
+        instances: [ ...args.instances.inFlight, ...args.instances.settled ],
+        issues: args.issues,
+        mappings: args.mappings,
+        now: args.now
+    });
+    return {
+        kind: "bands",
+        bands: catalogBands(rows)
+    };
 }
 
-function activeSummary(active) {
-    return active === 0 ? "No active instances" : pluralize("active instance", active, !0);
+function definitionAlert(row) {
+    if (row.signals.stuckCount !== 0) return {
+        hint: `${pluralize("run", row.signals.stuckCount, !0)} here can’t continue without help`
+    };
 }
 
-const CARD_MIN_WIDTH = 280, CARD_RADIUS$1 = 3, CARD_PADDING = 4, CARD_MIN_HEIGHT = 180;
+const CARD_MIN_WIDTH = 280, CARD_RADIUS$1 = 3, CARD_PADDING = 4, HINT_DOCUMENT_MAX_WIDTH = 200, BAND_GAP = 6, CARD_MIN_HEIGHT = 120;
 
-function OverviewTab({onOpenWorkflow: onOpenWorkflow}) {
-    const {definitions: definitions, error: error} = useDeployedDefinitions(), {mappingIssues: mappingIssues, mappings: mappings} = useWorkflowContext(), schema = useSchema(), instances = useToolInstances(), undeployed = /* @__PURE__ */ jsx(UndeployedWorkflows, {
+function OverviewTab({identity: identity, onOpenWorkflow: onOpenWorkflow}) {
+    const {definitions: definitions, error: error} = useDeployedDefinitions(), {mappingIssues: mappingIssues, mappings: mappings} = useWorkflowContext(), schema = useSchema(), instances = useToolInstances(), now = useMinuteClock(), view = catalogView({
+        definitions: definitions,
+        error: error,
+        identity: identity,
+        instances: instances,
+        issues: mappingIssues,
+        mappings: mappings,
+        now: now
+    }), undeployed = /* @__PURE__ */ jsx(UndeployedWorkflows, {
         notices: undeployedWorkflowNotices({
             issues: mappingIssues,
             titleOf: name => schema.get(name)?.title
         })
     });
-    if (error !== void 0) /* @__PURE__ */
-    return jsx(TabStatusRow, {
-        children: /* @__PURE__ */ jsx(Text, {
-            muted: !0,
-            size: 1,
-            children: catalogReadError(error)
-        })
-    });
-    if (definitions === void 0) /* @__PURE__ */
-    return jsx(TabStatusRow, {
+    return view.kind === "unreadable" ? /* @__PURE__ */ jsx(NoteBanner, {
+        label: CATALOG_READ_FAILED,
+        tone: "critical"
+    }) : view.kind === "loading" ? /* @__PURE__ */ jsx(TabStatusRow, {
         children: /* @__PURE__ */ jsx(LoadingRow, {
             label: "Loading workflows…"
         })
-    });
-    if (definitions.length === 0) /* @__PURE__ */
-    return jsxs(Flex, {
+    }) : view.kind === "empty" ? /* @__PURE__ */ jsxs(Flex, {
         direction: "column",
         flex: 1,
         gap: 3,
-        paddingBottom: 4,
+        paddingBottom: 3,
         paddingTop: 3,
         children: [ undeployed, 
         /* @__PURE__ */ jsx(EmptyState, {
@@ -583,67 +896,166 @@ function OverviewTab({onOpenWorkflow: onOpenWorkflow}) {
             icon: /* @__PURE__ */ jsx(TransferIcon, {}),
             title: "No workflows deployed"
         }) ]
-    });
-    const rows = definitionCatalog({
-        definitions: definitions,
-        mappings: mappings,
-        inFlight: instances.inFlight,
-        issues: mappingIssues
-    }), active = rows.reduce((sum, row) => sum + row.activeCount, 0);
-    /* @__PURE__ */
-    return jsxs(Stack, {
+    }) : /* @__PURE__ */ jsxs(Stack, {
         gap: 3,
         paddingBottom: 4,
         paddingTop: 3,
-        children: [ undeployed, 
-        /* @__PURE__ */ jsxs(Flex, {
-            align: "center",
-            gap: 2,
-            padding: TOOL_HEADING_PADDING,
-            children: [ 
-            /* @__PURE__ */ jsx(Text, {
-                size: 1,
-                weight: "semibold",
-                children: pluralize("workflow", rows.length, !0)
-            }), 
-            /* @__PURE__ */ jsx(Text, {
-                muted: !0,
-                size: 1,
-                children: instances.loading ? "counting active instances…" : activeSummary(active)
-            }) ]
+        children: [ undeployed, instances.error === void 0 ? null : /* @__PURE__ */ jsx(NoteBanner, {
+            label: INSTANCES_READ_FAILED,
+            tone: "critical"
         }), 
-        /* @__PURE__ */ jsx(Grid, {
-            gap: 3,
-            style: {
-                gridAutoRows: `minmax(${CARD_MIN_HEIGHT}px, auto)`,
-                gridTemplateColumns: `repeat(auto-fill, minmax(${CARD_MIN_WIDTH}px, 1fr))`
-            },
-            children: rows.map(row => /* @__PURE__ */ jsx(WorkflowCard, {
-                countPending: instances.loading,
-                onOpen: () => onOpenWorkflow(row.name),
-                row: row
-            }, row.name))
+        /* @__PURE__ */ jsx(Stack, {
+            gap: BAND_GAP,
+            children: view.bands.map(band => /* @__PURE__ */ jsxs(Stack, {
+                gap: 3,
+                children: [ band.title === void 0 ? null : /* @__PURE__ */ jsx(Box, {
+                    padding: TOOL_HEADING_PADDING,
+                    children: /* @__PURE__ */ jsx(CountedHeading, {
+                        count: band.rows.length,
+                        title: band.title
+                    })
+                }), 
+                /* @__PURE__ */ jsx(CardGrid, {
+                    countKnown: instances.error === void 0,
+                    now: now,
+                    onOpenWorkflow: onOpenWorkflow,
+                    rows: band.rows
+                }) ]
+            }, band.title ?? UNBANDED_KEY))
         }), instances.truncated ? /* @__PURE__ */ jsx(MutedNote, {
             text: INSTANCE_CAP_COUNT_NOTE
         }) : null ]
     });
 }
 
-const CARD_ISSUES_HINT = "This workflow has issues";
+const UNBANDED_KEY = "all";
+
+function CardGrid({countKnown: countKnown, now: now, onOpenWorkflow: onOpenWorkflow, rows: rows}) {
+    /* @__PURE__ */
+    return jsx(Grid, {
+        gap: 3,
+        style: {
+            gridAutoRows: `minmax(${CARD_MIN_HEIGHT}px, auto)`,
+            gridTemplateColumns: `repeat(auto-fill, minmax(${CARD_MIN_WIDTH}px, 1fr))`
+        },
+        children: rows.map(row => /* @__PURE__ */ jsx(WorkflowCard, {
+            countKnown: countKnown,
+            now: now,
+            onOpen: () => onOpenWorkflow(row.name),
+            row: row
+        }, row.name))
+    });
+}
 
 function UndeployedWorkflows({notices: notices}) {
     return notices.length === 0 ? null : 
     /* @__PURE__ */ jsx(Stack, {
         gap: 2,
         paddingBottom: 1,
-        children: notices.map(notice => /* @__PURE__ */ jsx(CautionNote, {
+        children: notices.map(notice => /* @__PURE__ */ jsx(NoteBanner, {
             label: notice
         }, notice))
     });
 }
 
-function WorkflowCard({countPending: countPending, onOpen: onOpen, row: row}) {
-    const flagged = row.brokenBindings.length > 0, card = /* @__PURE__ */ jsx(Card, {
+function LastTransitionHint({transition: transition}) {
+    const documents = useMemo(() => transition.document === void 0 ? [] : [ transition.document ], [ transition.document ]), {resolved: resolved, titles: titles} = useDocPreviewTitles(documents), id = transition.document?.id, face = transitionFace({
+        at: transition.at,
+        documentPending: id !== void 0 && !resolved.has(id),
+        documentTitle: id === void 0 ? void 0 : titles.get(id) ?? UNTITLED_DOCUMENT,
+        stage: transition.stage
+    });
+    return face.state === "pending" ? /* @__PURE__ */ jsx(Text, {
+        muted: !0,
+        size: 1,
+        children: TRANSITION_HINT_PENDING
+    }) : 
+    /* @__PURE__ */ jsxs(Stack, {
+        gap: 3,
+        children: [ 
+        /* @__PURE__ */ jsx(Text, {
+            muted: !0,
+            size: 1,
+            children: face.heading
+        }), 
+        /* @__PURE__ */ jsxs(Text, {
+            size: 1,
+            textOverflow: "ellipsis",
+            children: [ face.document === void 0 ? null : /* @__PURE__ */ jsx(HintDocument, {
+                children: face.document
+            }), face.document === void 0 ? "" : " ", face.lead, " ", 
+            /* @__PURE__ */ jsx(InlineEmphasis, {
+                children: face.stage
+            }) ]
+        }) ]
+    });
+}
+
+function HintDocument({children: children}) {
+    /* @__PURE__ */
+    return jsx("span", {
+        style: {
+            display: "inline-block",
+            maxWidth: HINT_DOCUMENT_MAX_WIDTH,
+            overflow: "hidden",
+            textOverflow: "ellipsis",
+            verticalAlign: "bottom",
+            whiteSpace: "nowrap"
+        },
+        children: /* @__PURE__ */ jsx(InlineEmphasis, {
+            children: children
+        })
+    });
+}
+
+function overdueWork(signals) {
+    return {
+        documentCount: signals.overdueDocumentCount,
+        documentlessCount: signals.overdueDocumentlessCount
+    };
+}
+
+function CardMetrics$1({now: now, signals: signals}) {
+    const overdue = overdueWork(signals), overdueTotal = overdue.documentCount + overdue.documentlessCount, documents = documentFace(signals, signals.initialStageDocumentCount);
+    /* @__PURE__ */
+    return jsxs(Flex, {
+        align: "center",
+        gap: 3,
+        children: [ 
+        /* @__PURE__ */ jsx(MetricPair, {
+            Icon: DocumentIcon,
+            empty: signals.documentCount === 0 && signals.documentlessCount === 0,
+            face: {
+                text: documents.lead,
+                ...documents.startLine === void 0 ? {} : {
+                    description: documents.startLine
+                }
+            },
+            value: String(signals.documentCount)
+        }), signals.lastTransition === void 0 ? null : /* @__PURE__ */ jsx(MetricPair, {
+            Icon: ClockIcon,
+            face: {
+                content: /* @__PURE__ */ jsx(LastTransitionHint, {
+                    transition: signals.lastTransition
+                }),
+                wide: !0
+            },
+            value: formatShortAgo(signals.lastTransition.at, now)
+        }), overdueTotal === 0 ? null : /* @__PURE__ */ jsx(MetricPair, {
+            Icon: CalendarIcon,
+            face: {
+                text: overdueHint(overdue)
+            },
+            tone: "caution",
+            value: String(overdueTotal)
+        }) ]
+    });
+}
+
+function WorkflowCard({countKnown: countKnown, now: now, onOpen: onOpen, row: row}) {
+    const alert = definitionAlert(row);
+    /* @__PURE__ */
+    return jsxs(Card, {
         as: "button",
         onClick: onOpen,
         padding: CARD_PADDING,
@@ -656,50 +1068,44 @@ function WorkflowCard({countPending: countPending, onOpen: onOpen, row: row}) {
             textAlign: "left",
             width: "100%"
         },
-        ...flagged ? {
-            tone: "caution"
-        } : {},
-        children: /* @__PURE__ */ jsxs(Flex, {
+        children: [ 
+        /* @__PURE__ */ jsxs(Flex, {
             align: "flex-start",
-            gap: 3,
-            children: [ flagged ? /* @__PURE__ */ jsx(Text, {
-                size: 1,
-                children: /* @__PURE__ */ jsx(WarningOutlineIcon, {})
-            }) : null, 
-            /* @__PURE__ */ jsxs(Stack, {
+            gap: 2,
+            style: {
                 flex: 1,
-                gap: 3,
+                minWidth: 0
+            },
+            children: [ 
+            /* @__PURE__ */ jsx(Text, {
+                size: 1,
                 style: {
+                    flex: 1,
                     minWidth: 0
                 },
-                children: [ 
-                /* @__PURE__ */ jsx(Text, {
-                    size: 1,
-                    weight: "semibold",
-                    children: row.title
-                }), countPending ? null : /* @__PURE__ */ jsx(Text, {
-                    muted: !0,
-                    size: 1,
-                    children: activeSummary(row.activeCount)
-                }) ]
+                weight: "medium",
+                children: row.title
+            }), alert === void 0 ? null : /* @__PURE__ */ jsx(AlertGlyph, {
+                Icon: ErrorOutlineIcon,
+                hint: alert.hint,
+                tone: "critical"
             }) ]
-        })
+        }), countKnown ? /* @__PURE__ */ jsx(CardMetrics$1, {
+            now: now,
+            signals: row.signals
+        }) : null ]
     });
-    return flagged ? /* @__PURE__ */ jsx(HoverHint, {
-        fill: !0,
-        text: CARD_ISSUES_HINT,
-        children: card
-    }) : card;
 }
 
 function useStartableDefinitions() {
-    const {definitions: definitions, error: error} = useDeployedDefinitions();
+    const {definitions: definitions, error: error} = useDeployedDefinitions(), startable = useMemo(() => definitions?.filter(row => isStartableDefinition(row)).map(row => ({
+        name: row.name,
+        title: row.title ?? row.name,
+        description: row.description
+    })), [ definitions ]);
     return {
-        definitions: useMemo(() => definitions?.filter(row => isStartableDefinition(row)).map(row => ({
-            name: row.name,
-            title: row.title ?? row.name,
-            description: row.description
-        })), [ definitions ]),
+        catalogEmpty: definitions?.length === 0,
+        definitions: startable,
         error: error
     };
 }
@@ -731,16 +1137,45 @@ function NewWorkflowButton() {
     });
 }
 
+const PANEL_WIDTH = 340;
+
+function NothingToStart({catalogEmpty: catalogEmpty}) {
+    /* @__PURE__ */
+    return jsx(Box, {
+        padding: 4,
+        style: {
+            width: PANEL_WIDTH
+        },
+        children: /* @__PURE__ */ jsxs(Stack, {
+            gap: 3,
+            children: [ 
+            /* @__PURE__ */ jsx(Text, {
+                align: "center",
+                size: 1,
+                weight: "medium",
+                children: catalogEmpty ? "No workflows deployed" : "Nothing to start by hand"
+            }), 
+            /* @__PURE__ */ jsx(Text, {
+                align: "center",
+                muted: !0,
+                size: 1,
+                children: catalogEmpty ? "Deploy a workflow to this project to start one from here" : "Every deployed workflow here is started by a parent workflow, never by hand"
+            }) ]
+        })
+    });
+}
+
 function DefinitionPickerPanel({onPick: onPick}) {
-    const {definitions: definitions, error: error} = useStartableDefinitions(), [query, setQuery] = useState(""), visible = useMemo(() => {
+    const {catalogEmpty: catalogEmpty, definitions: definitions, error: error} = useStartableDefinitions(), [query, setQuery] = useState(""), visible = useMemo(() => {
         const q = query.trim().toLowerCase();
         return definitions ? q ? definitions.filter(d => `${d.title} ${d.name}`.toLowerCase().includes(q)) : definitions : [];
-    }, [ definitions, query ]);
-    /* @__PURE__ */
-    return jsx(Box, {
+    }, [ definitions, query ]), settled = error === void 0 ? definitions : void 0;
+    return settled?.length === 0 ? /* @__PURE__ */ jsx(NothingToStart, {
+        catalogEmpty: catalogEmpty
+    }) : /* @__PURE__ */ jsx(Box, {
         padding: 2,
         style: {
-            width: 340
+            width: PANEL_WIDTH
         },
         children: /* @__PURE__ */ jsxs(Stack, {
             gap: 2,
@@ -752,13 +1187,12 @@ function DefinitionPickerPanel({onPick: onPick}) {
                 onChange: event => setQuery(event.currentTarget.value),
                 placeholder: "Filter workflows…",
                 value: query
-            }), error ? /* @__PURE__ */ jsx(MutedNote, {
-                text: catalogReadError(error)
+            }), error ? /* @__PURE__ */ jsx(NoteBanner, {
+                label: CATALOG_READ_FAILED,
+                tone: "critical"
             }) : null, !definitions && !error ? /* @__PURE__ */ jsx(LoadingRow, {
                 label: "Loading workflows…"
-            }) : null, definitions && definitions.length === 0 ? /* @__PURE__ */ jsx(MutedNote, {
-                text: "No startable workflows are deployed"
-            }) : null, definitions && definitions.length > 0 && visible.length === 0 ? /* @__PURE__ */ jsx(MutedNote, {
+            }) : null, settled !== void 0 && settled.length > 0 && visible.length === 0 ? /* @__PURE__ */ jsx(MutedNote, {
                 text: "No workflows match"
             }) : null, 
             /* @__PURE__ */ jsx(Stack, {
@@ -1036,13 +1470,20 @@ function useBandOpen(bands, key) {
     };
 }
 
-const REVEAL_MAX_WAIT_MS = 2e3;
+const REVEAL_STALL_MS = 2e3, REVEAL_COLD_MS = 15e3;
 
 function useRevealGate(args) {
-    const {loading: loading, ready: ready} = args, settled = !loading && ready, expired = useDelayedFlag(!loading && !ready, REVEAL_MAX_WAIT_MS), [revealed, setRevealed] = useState(!1);
+    const {loading: loading, progress: progress, ready: ready} = args, settled = !loading && ready, [stalled, setStalled] = useState(!1);
+    useEffect(() => {
+        if (loading || ready) return;
+        setStalled(!1);
+        const budget = progress > 0 ? REVEAL_STALL_MS : REVEAL_COLD_MS, timer = setTimeout(() => setStalled(!0), budget);
+        return () => clearTimeout(timer);
+    }, [ loading, progress, ready ]);
+    const [revealed, setRevealed] = useState(!1);
     return useEffect(() => {
-        !revealed && (settled || expired) && setRevealed(!0);
-    }, [ expired, revealed, settled ]), revealed || settled || expired;
+        !revealed && (settled || stalled) && setRevealed(!0);
+    }, [ revealed, settled, stalled ]), revealed || settled || stalled;
 }
 
 function spawnOrigins(instances) {
@@ -1055,11 +1496,6 @@ function spawnOrigins(instances) {
     return origins;
 }
 
-function rootOf(instance, byId) {
-    const rootRef = instance.ancestors[0];
-    return rootRef ? byId.get(toBareId(rootRef.id)) ?? instance : instance;
-}
-
 function taskRowsOf(args) {
     const {instance: instance, identity: identity} = args, open = findOpenStageEntry(instance);
     if (!open) return [];
@@ -1089,6 +1525,10 @@ function taskRowsOf(args) {
                 state: fields,
                 who: identity
             }),
+            roleMatched: identity !== void 0 && isRoleAssignedTo({
+                state: fields,
+                who: identity
+            }),
             assignControl: rowAssignControlState(controlArgs),
             dateControl: rowDateControlState(controlArgs)
         };
@@ -1115,7 +1555,7 @@ function deriveTaskGroups(args) {
                 activityName: origin.activityName
             }).title : void 0,
             rows: rows
-        }, root = rootOf(instance, byId), documents = documentRefsOf(root), document2 = documents[0];
+        }, root = rootInstanceOf(instance, byId), documents = documentRefsOf(root), document2 = documents[0];
         if (!document2) {
             withoutDocuments.push(entry);
             continue;
@@ -1171,6 +1611,11 @@ function onlyMyTasks(groups) {
     });
 }
 
+function hasRoleMatchedTasks(groups) {
+    const bandHasOne = band => band.rows.some(row => row.roleMatched);
+    return groups.withDocuments.some(group => group.instances.some(bandHasOne)) || groups.withoutDocuments.some(bandHasOne);
+}
+
 function rowActivityEval(entry, row) {
     const evaluation = entry?.evaluation;
     if (!(evaluation === void 0 || evaluation.currentStage.stage.name !== row.stage)) return evaluation.currentStage.activities.find(a => a.activity.name === row.activityName);
@@ -1314,7 +1759,7 @@ function OrphanedWorkflowsNote({orphans: orphans}) {
     /* @__PURE__ */
     return jsxs(Fragment, {
         children: [ 
-        /* @__PURE__ */ jsx(CautionNote, {
+        /* @__PURE__ */ jsx(NoteBanner, {
             action: /* @__PURE__ */ jsx(Button, {
                 fontSize: 1,
                 mode: "ghost",
@@ -1416,72 +1861,6 @@ function SettleOrphansDialog({workflows: workflows, onClose: onClose}) {
     });
 }
 
-const NO_TITLES = {
-    titles: /* @__PURE__ */ new Map,
-    resolved: /* @__PURE__ */ new Set
-};
-
-function useDocPreviewTitles(documents) {
-    const previewStore = useDocumentPreviewStore(), schema = useSchema(), {perspectiveStack: perspectiveStack} = usePerspective(), {actualTypes: actualTypes, binding: binding} = useWorkflowContext(), [state, setState] = useState(NO_TITLES), key = documents.map(doc => doc.id).join("|");
-    return useEffect(() => {
-        const titles = /* @__PURE__ */ new Map, resolved = /* @__PURE__ */ new Set, previews = /* @__PURE__ */ new Map, publish = () => setState({
-            titles: new Map(titles),
-            resolved: new Set(resolved)
-        }), localDocs = documents.flatMap(doc => {
-            const {parsed: parsed, local: local} = gdrLocality(doc.id, binding.contentResource);
-            return !parsed || !local ? (resolved.add(doc.id), []) : [ {
-                doc: doc,
-                bareId: parsed.documentId
-            } ];
-        }), untracks = localDocs.map(({bareId: bareId}) => actualTypes.track(bareId)), dropPreview = docId => {
-            previews.get(docId)?.unsubscribe(), previews.delete(docId), titles.delete(docId);
-        }, observe = ({docId: docId, bareId: bareId, typeName: typeName}) => {
-            const schemaType = openableSchemaType(schema, typeName);
-            if (!schemaType) return !1;
-            if (previews.get(docId)?.typeName === typeName) return !0;
-            dropPreview(docId), resolved.delete(docId);
-            const subscription = previewStore.observeForPreview({
-                _id: bareId,
-                _type: schemaType.name
-            }, schemaType, {
-                perspective: perspectiveStack
-            }).subscribe({
-                next: event => {
-                    resolved.add(docId);
-                    const title = event.snapshot?.title;
-                    typeof title == "string" ? titles.set(docId, title) : titles.delete(docId), publish();
-                },
-                error: err => {
-                    console.error(`[workflow-studio-plugin] preview for "${docId}" failed:`, err), resolved.add(docId), 
-                    publish();
-                }
-            });
-            return previews.set(docId, {
-                typeName: typeName,
-                unsubscribe: () => subscription.unsubscribe()
-            }), !0;
-        }, evaluate = () => {
-            for (const {doc: doc, bareId: bareId} of localDocs) {
-                const probe = actualTypes.read(bareId);
-                if (probe === null) {
-                    dropPreview(doc.id), resolved.add(doc.id);
-                    continue;
-                }
-                !observe({
-                    docId: doc.id,
-                    bareId: bareId,
-                    typeName: probe ?? doc.type
-                }) && typeof probe == "string" && (dropPreview(doc.id), resolved.add(doc.id));
-            }
-            publish();
-        }, unsubscribeProbes = actualTypes.subscribe(evaluate);
-        return evaluate(), () => {
-            unsubscribeProbes(), untracks.forEach(untrack => untrack()), previews.forEach(preview => preview.unsubscribe());
-        };
-    }, [ key, previewStore, schema, actualTypes, binding.contentResource.id, perspectiveStack.join("|") ]), 
-    state;
-}
-
 function taskFilterOptions(groups) {
     const workflows = /* @__PURE__ */ new Map, documents = /* @__PURE__ */ new Map;
     for (const group of groups.withDocuments) {
@@ -2650,7 +3029,7 @@ function useOrphanedWorkflows(groups) {
     }), [ groups, contentResource, missing ]);
 }
 
-function TasksTab({filterSlot: filterSlot, instances: instances, loading: loading, identity: identity, onOpenInstance: onOpenInstance, onOpenTask: onOpenTask, tab: tab, truncated: truncated, unreadable: unreadable}) {
+function TasksTab({error: error, filterSlot: filterSlot, instances: instances, loading: loading, identity: identity, onOpenInstance: onOpenInstance, onOpenTask: onOpenTask, tab: tab, truncated: truncated, unreadable: unreadable}) {
     const mineOnly = tab === "for-me", {binding: binding} = useWorkflowContext(), bands = useBandOpenState({
         segment: TASK_BAND_SEGMENTS[tab],
         scope: binding.engineResource.id
@@ -2659,6 +3038,7 @@ function TasksTab({filterSlot: filterSlot, instances: instances, loading: loadin
         identity: identity
     }), [ instances, identity ]), orphans = useOrphanedWorkflows(groups), listed = useMemo(() => hideOrphanedGroups(groups, orphans.groupKeys), [ groups, orphans.groupKeys ]), options = useMemo(() => taskFilterOptions(listed), [ listed ]), titles = useGroupTitles(listed), revealed = useRevealGate({
         loading: loading,
+        progress: titles.resolved.size,
         ready: titles.ready
     }), visible = useMemo(() => {
         const filtered = applyTaskFilters({
@@ -2668,6 +3048,10 @@ function TasksTab({filterSlot: filterSlot, instances: instances, loading: loadin
         }), cut = mineOnly ? onlyMyTasks(filtered) : filtered;
         return orderGroupsByPreviewTitle(cut, titles.titles);
     }, [ listed, filters, mineOnly, titles ]);
+    if (error !== void 0) /* @__PURE__ */ return jsx(NoteBanner, {
+        label: INSTANCES_READ_FAILED,
+        tone: "critical"
+    });
     if (loading || !revealed) /* @__PURE__ */
     return jsx(TabStatusRow, {
         children: /* @__PURE__ */ jsx(LoadingRow, {
@@ -2707,13 +3091,37 @@ function TasksTab({filterSlot: filterSlot, instances: instances, loading: loadin
             }), 
             /* @__PURE__ */ jsx(OrphanedWorkflowsNote, {
                 orphans: orphans
-            }), body, truncated ? /* @__PURE__ */ jsx(MutedNote, {
+            }), mineOnly && hasRoleMatchedTasks(visible) ? /* @__PURE__ */ jsx(RoleAssignedNotice, {}) : null, body, truncated ? /* @__PURE__ */ jsx(MutedNote, {
                 text: `Tasks from the latest ${INSTANCE_CAP} workflows — older ones aren’t listed.`
             }) : null ]
         }) ]
     });
 }
 
+function cardFacts(args) {
+    return new Map(args.instances.map(instance => [ instance._id, {
+        pending: openActivitiesOf(instance).length,
+        overdue: overdueTaskCount(instance, args.now),
+        stuck: documentStuckCause({
+            instance: instance,
+            definition: definitionSnapshotOf(instance)
+        }) !== void 0,
+        settled: terminalState(instance) !== "in-flight"
+    } ]));
+}
+
+function laneTotals(cards, facts) {
+    let overdue = 0, stuck = 0;
+    for (const card of cards) {
+        const held = facts.get(card.instanceId);
+        held !== void 0 && (held.overdue > 0 && (overdue += 1), held.stuck && (stuck += 1));
+    }
+    return {
+        overdue: overdue,
+        stuck: stuck
+    };
+}
+
 const BOARD_EMPTY_STAGE_NOTE = "No items";
 
 function faceOf(instance) {
@@ -2772,6 +3180,24 @@ function boardDocuments(board) {
     return board.groups.flatMap(group => group.cards.flatMap(card => card.face.kind === "document" ? [ card.face.document ] : []));
 }
 
+function pendingHint(pending) {
+    return pending === 0 ? "All tasks done" : `${pluralize("task", pending, !0)} still open`;
+}
+
+function overdueTasksHint(overdue) {
+    return `${pluralize("task", overdue, !0)} past ${overdue === 1 ? "its" : "their"} due date`;
+}
+
+const STUCK_RUN_HINT = "This run can’t continue without help";
+
+function laneOverdueHint(overdue) {
+    return `${overdue} of these ${overdue === 1 ? "has" : "have"} overdue tasks`;
+}
+
+function laneStuckHint(stuck) {
+    return `${stuck} of these can’t continue without help`;
+}
+
 function CardTitleFace({title: title}) {
     return title.kind === "title" ? /* @__PURE__ */ jsx(Fragment, {
         children: title.title
@@ -2798,23 +3224,10 @@ function cardTitle(args) {
     };
 }
 
-function ownOpenTasks(instance) {
-    const open = findOpenStageEntry(instance);
-    return open ? (open.activities ?? []).filter(activity => isOpenActivityStatus(activity.status)).length : 0;
-}
-
-function pendingTaskCounts(instances) {
-    return new Map(instances.map(instance => [ instance._id, ownOpenTasks(instance) ]));
-}
-
-function pendingTasksPhrase(pending) {
-    if (pending !== void 0) return pending === 0 ? "All tasks done" : pluralize("pending task", pending, !0);
-}
-
 const CARD_RADIUS = 3;
 
 function BoardCard({card: card, wiring: wiring}) {
-    const {onSelect: onSelect, pending: pending, selectedInstanceId: selectedInstanceId, titles: titles} = wiring, {color: color} = useTheme_v2(), selected = card.instanceId === selectedInstanceId;
+    const {facts: facts, onSelect: onSelect, selectedInstanceId: selectedInstanceId, titles: titles} = wiring, {color: color} = useTheme_v2(), selected = card.instanceId === selectedInstanceId, held = facts.get(card.instanceId);
     /* @__PURE__ */
     return jsx(Card, {
         "aria-pressed": selected,
@@ -2832,54 +3245,93 @@ function BoardCard({card: card, wiring: wiring}) {
         children: /* @__PURE__ */ jsxs(Stack, {
             gap: 3,
             children: [ 
-            /* @__PURE__ */ jsx(Text, {
-                size: 1,
-                weight: "medium",
-                children: /* @__PURE__ */ jsx(CardTitleFace, {
-                    title: cardTitle({
-                        face: card.face,
-                        titles: titles
+            /* @__PURE__ */ jsxs(Flex, {
+                align: "flex-start",
+                gap: 2,
+                children: [ 
+                /* @__PURE__ */ jsx(Text, {
+                    size: 1,
+                    style: {
+                        flex: 1,
+                        minWidth: 0
+                    },
+                    weight: "medium",
+                    children: /* @__PURE__ */ jsx(CardTitleFace, {
+                        title: cardTitle({
+                            face: card.face,
+                            titles: titles
+                        })
                     })
-                })
-            }), 
-            /* @__PURE__ */ jsx(PendingTasks, {
-                pending: pending.get(card.instanceId)
+                }), held?.stuck === !0 ? /* @__PURE__ */ jsx(AlertGlyph, {
+                    Icon: ErrorOutlineIcon,
+                    hint: STUCK_RUN_HINT,
+                    tone: "critical"
+                }) : null ]
+            }), held === void 0 ? null : /* @__PURE__ */ jsx(CardMetrics, {
+                facts: held
             }) ]
         })
     });
 }
 
-function PendingTasks({pending: pending}) {
-    const badgeTrim = useBadgeCapTrim(), phrase = pendingTasksPhrase(pending);
-    return phrase === void 0 ? null : /* @__PURE__ */ jsx(Flex, {
+function CardMetrics({facts: facts}) {
+    return facts.settled ? null : /* @__PURE__ */ jsxs(Flex, {
         align: "center",
-        style: badgeTrim,
-        children: /* @__PURE__ */ jsx(Card, {
-            padding: 2,
-            radius: 2,
-            tone: "transparent",
-            children: /* @__PURE__ */ jsx(Text, {
-                muted: pending === 0,
-                size: 1,
-                children: phrase
-            })
-        })
+        gap: 3,
+        children: [ 
+        /* @__PURE__ */ jsx(MetricPair, {
+            Icon: EmptyIcon,
+            empty: facts.pending === 0,
+            face: {
+                text: pendingHint(facts.pending)
+            },
+            value: String(facts.pending)
+        }), facts.overdue === 0 ? null : /* @__PURE__ */ jsx(MetricPair, {
+            Icon: CalendarIcon,
+            face: {
+                text: overdueTasksHint(facts.overdue)
+            },
+            tone: "caution",
+            value: String(facts.overdue)
+        }) ]
     });
 }
 
-function StageGroupHeading({group: group}) {
+function StageGroupHeading({facts: facts, group: group}) {
+    const totals = laneTotals(group.cards, facts);
     /* @__PURE__ */
     return jsxs(Flex, {
         align: "center",
         gap: 2,
         children: [ 
-        /* @__PURE__ */ jsx(CountedLabel, {
+        /* @__PURE__ */ jsx(CountedHeading, {
             count: group.cards.length,
-            label: /* @__PURE__ */ jsx(Text, {
-                size: 1,
-                weight: "semibold",
-                children: group.title
-            })
+            title: group.title
+        }), totals.overdue === 0 && totals.stuck === 0 ? null : /* @__PURE__ */ jsxs(Fragment, {
+            children: [ 
+            /* @__PURE__ */ jsx(Flex, {
+                flex: 1
+            }), 
+            /* @__PURE__ */ jsxs(Flex, {
+                align: "center",
+                flex: "none",
+                gap: 3,
+                children: [ totals.overdue === 0 ? null : /* @__PURE__ */ jsx(MetricPair, {
+                    Icon: CalendarIcon,
+                    face: {
+                        text: laneOverdueHint(totals.overdue)
+                    },
+                    tone: "caution",
+                    value: String(totals.overdue)
+                }), totals.stuck === 0 ? null : /* @__PURE__ */ jsx(MetricPair, {
+                    Icon: ErrorOutlineIcon,
+                    face: {
+                        text: laneStuckHint(totals.stuck)
+                    },
+                    tone: "critical",
+                    value: String(totals.stuck)
+                }) ]
+            }) ]
         }), group.retired ? 
         /* @__PURE__ */ jsx(Text, {
             muted: !0,
@@ -2928,6 +3380,7 @@ function StageColumn({group: group, leadingRule: leadingRule, trailingRule: trai
             paddingTop: 4,
             paddingX: LANE_PADDING,
             children: /* @__PURE__ */ jsx(StageGroupHeading, {
+                facts: wiring.facts,
                 group: group
             })
         }), group.cards.length === 0 ? /* @__PURE__ */ jsx(Flex, {
@@ -3068,7 +3521,7 @@ function useBoard(args) {
     }), {titles: titles, ready: ready} = seeded, board = useMemo(() => derived ? orderBoardByPreviewTitle(derived, titles) : void 0, [ derived, titles ]);
     return useMemo(() => ({
         board: board,
-        ready: ready,
+        ready: board !== void 0 && ready,
         titles: seeded
     }), [ board, ready, seeded ]);
 }
@@ -3085,6 +3538,16 @@ function useBoardInstances(definitionName) {
     return useCappedInstances(filter);
 }
 
+function activeCountFace(args) {
+    return args.error !== void 0 || args.loading ? {
+        count: void 0,
+        note: void 0
+    } : {
+        count: args.count,
+        note: args.truncated ? INSTANCE_CAP_COUNT_NOTE : void 0
+    };
+}
+
 function DefinitionPanel({definition: definition}) {
     /* @__PURE__ */
     return jsx(Box, {
@@ -3147,12 +3610,31 @@ function SetupIssues({bindings: bindings}) {
     });
 }
 
+function ActiveCount({face: face}) {
+    /* @__PURE__ */
+    return jsxs(Stack, {
+        gap: 2,
+        children: [ 
+        /* @__PURE__ */ jsx(Text, {
+            muted: face.count === void 0,
+            size: 1,
+            children: face.count ?? "—"
+        }), face.note === void 0 ? null : /* @__PURE__ */ jsx(Text, {
+            muted: !0,
+            size: 1,
+            children: face.note
+        }) ]
+    });
+}
+
 function DefinitionFacts({definition: definition}) {
-    const {mappingIssues: mappingIssues, mappings: mappings} = useWorkflowContext(), schema = useSchema(), instances = useToolInstances(), snapshotWidth = useContainerToken(2), [row] = definitionCatalog({
+    const {mappingIssues: mappingIssues, mappings: mappings} = useWorkflowContext(), schema = useSchema(), instances = useToolInstances(), now = useMinuteClock(), snapshotWidth = useContainerToken(2), [row] = definitionCatalog({
         definitions: [ definition ],
+        identity: void 0,
         mappings: mappings,
-        inFlight: instances.inFlight,
-        issues: mappingIssues
+        instances: [ ...instances.inFlight, ...instances.settled ],
+        issues: mappingIssues,
+        now: now
     }), runsOn = docTypeLabels(row?.docTypes ?? [], name => schema.get(name)?.title).map(docType => docType.title);
     /* @__PURE__ */
     return jsxs(Flex, {
@@ -3164,6 +3646,12 @@ function DefinitionFacts({definition: definition}) {
             children: /* @__PURE__ */ jsx(SetupIssues, {
                 bindings: row.brokenBindings
             })
+        }), instances.error === void 0 ? null : /* @__PURE__ */ jsx(Box, {
+            flex: "none",
+            children: /* @__PURE__ */ jsx(NoteBanner, {
+                label: INSTANCES_READ_FAILED,
+                tone: "critical"
+            })
         }), 
         /* @__PURE__ */ jsx(Box, {
             flex: "none",
@@ -3182,21 +3670,13 @@ function DefinitionFacts({definition: definition}) {
                 }), 
                 /* @__PURE__ */ jsx(MetaRow, {
                     label: "Active instances",
-                    children: instances.loading ? /* @__PURE__ */ jsx(Text, {
-                        muted: !0,
-                        size: 1,
-                        children: "—"
-                    }) : /* @__PURE__ */ jsxs(Stack, {
-                        gap: 2,
-                        children: [ 
-                        /* @__PURE__ */ jsx(Text, {
-                            size: 1,
-                            children: row?.activeCount ?? 0
-                        }), instances.truncated ? /* @__PURE__ */ jsx(Text, {
-                            muted: !0,
-                            size: 1,
-                            children: INSTANCE_CAP_COUNT_NOTE
-                        }) : null ]
+                    children: /* @__PURE__ */ jsx(ActiveCount, {
+                        face: activeCountFace({
+                            count: row?.signals.activeCount ?? 0,
+                            error: instances.error,
+                            loading: instances.loading,
+                            truncated: instances.truncated
+                        })
                     })
                 }), 
                 /* @__PURE__ */ jsx(MetaRow, {
@@ -3260,7 +3740,7 @@ function pickerLabel(face) {
 }
 
 function WorkflowPicker({face: face, onSelect: onSelect, options: options}) {
-    const empty = options.length === 0;
+    const empty = options.length === 0, reclaimed = -useSpaceToken(TOOL_HEADING_PADDING);
     /* @__PURE__ */
     return jsx(MenuButton, {
         button: /* @__PURE__ */ jsx(Button, {
@@ -3270,6 +3750,9 @@ function WorkflowPicker({face: face, onSelect: onSelect, options: options}) {
             iconRight: ChevronDownIcon,
             mode: "bleed",
             padding: TOOL_HEADING_PADDING,
+            style: {
+                margin: reclaimed
+            },
             text: pickerLabel(face),
             textWeight: "semibold"
         }),
@@ -3300,6 +3783,7 @@ function WorkflowPageHeader({face: face, onSelectPage: onSelectPage, onSelectWor
         children: [ 
         /* @__PURE__ */ jsx(Flex, {
             align: "center",
+            padding: TOOL_HEADING_PADDING,
             children: /* @__PURE__ */ jsx(WorkflowPicker, {
                 face: face,
                 onSelect: onSelectWorkflow,
@@ -3733,30 +4217,38 @@ function usePageSelection(page) {
 }
 
 function WorkflowPage({onOpenWorkflow: onOpenWorkflow, onSelectPage: onSelectPage, page: page, workflowName: workflowName}) {
-    const {definitions: definitions, error: error} = useDeployedDefinitions(), selection = resolveWorkflowSelection({
+    const {definitions: definitions, error: catalogError} = useDeployedDefinitions(), selection = resolveWorkflowSelection({
         definitions: definitions,
         routeName: workflowName
     }), selected = resolvedDefinition(selection), view = workflowPageView({
-        error: error,
+        error: catalogError,
         page: page,
         selection: selection
     }), instances = useBoardInstances(view.streamName), {board: board, ready: ready, titles: titles} = useBoard({
         definition: selected,
         instances: instances.rows
-    }), {select: select, selectedInstanceId: selectedInstanceId} = usePageSelection(page), panel = usePanelPresence(panelSubject({
+    }), {select: select, selectedInstanceId: selectedInstanceId} = usePageSelection(page), now = useMinuteClock(), panel = usePanelPresence(panelSubject({
         board: board,
         selectedInstanceId: selectedInstanceId
     })), revealed = useRevealGate({
         loading: instances.loading,
+        progress: titles.resolved.size,
         ready: ready
-    }), waiting = useDelayedFlag(selection.kind === "loading" && error === void 0, WAIT_CUE_DELAY_MS);
+    });
     if (selection.kind === "loading") /* @__PURE__ */ return jsx(UnresolvedPage, {
-        error: error,
-        waiting: waiting
+        error: catalogError
+    });
+    const catalogEmpty = (definitions ?? []).length === 0;
+    if (selection.kind === "unknown" && catalogEmpty) /* @__PURE__ */
+    return jsx(EmptyCatalogPage, {
+        name: selection.name
     });
     const wiring = {
         onSelect: select,
-        pending: pendingTaskCounts(instances.rows),
+        facts: cardFacts({
+            instances: instances.rows,
+            now: now
+        }),
         selectedInstanceId: selectedInstanceId,
         titles: titles
     };
@@ -3809,8 +4301,9 @@ function WorkflowPage({onOpenWorkflow: onOpenWorkflow, onSelectPage: onSelectPag
                 }), 
                 /* @__PURE__ */ jsx(PageBody, {
                     board: board,
-                    catalogEmpty: (definitions ?? []).length === 0,
-                    error: error,
+                    catalogEmpty: catalogEmpty,
+                    catalogError: catalogError,
+                    instancesError: instances.error,
                     loading: !revealed,
                     page: page,
                     selection: selection,
@@ -3838,45 +4331,66 @@ function WorkflowPage({onOpenWorkflow: onOpenWorkflow, onSelectPage: onSelectPag
     });
 }
 
-const WAIT_CUE_DELAY_MS = 300;
-
-function UnresolvedPage({error: error, waiting: waiting}) {
+function UnresolvedPage({error: error}) {
     /* @__PURE__ */
     return jsx(Flex, {
         direction: "column",
         height: "fill",
         overflow: "hidden",
-        children: error === void 0 ? /* @__PURE__ */ jsx(WaitingFace, {
-            waiting: waiting
-        }) : /* @__PURE__ */ jsx(CatalogErrorFace, {
-            error: error
+        children: error === void 0 ? /* @__PURE__ */ jsx(WaitingFace, {}) : /* @__PURE__ */ jsx(ReadErrorFace, {
+            text: CATALOG_READ_FAILED
         })
     });
 }
 
-function WaitingFace({waiting: waiting}) {
+function WaitingFace() {
     /* @__PURE__ */
     return jsx(StatusBox, {
-        children: waiting ? /* @__PURE__ */ jsx(TabStatusRow, {
+        children: /* @__PURE__ */ jsx(TabStatusRow, {
             children: /* @__PURE__ */ jsx(LoadingRow, {
                 label: "Loading workflow…"
             })
-        }) : null
+        })
+    });
+}
+
+function EmptyCatalogPage({name: name}) {
+    const face = unknownWorkflowFace({
+        catalogEmpty: !0,
+        name: name
+    });
+    /* @__PURE__ */
+    return jsx(Flex, {
+        direction: "column",
+        height: "fill",
+        overflow: "hidden",
+        padding: LANE_PADDING,
+        children: /* @__PURE__ */ jsx(EmptyState, {
+            description: face.description,
+            icon: /* @__PURE__ */ jsx(SearchIcon, {}),
+            title: face.title
+        })
     });
 }
 
-function CatalogErrorFace({error: error}) {
+const BANNER_LANE_INSET = 2;
+
+function ReadErrorFace({text: text}) {
     /* @__PURE__ */
     return jsx(StatusBox, {
-        children: /* @__PURE__ */ jsx(MutedNote, {
-            text: catalogReadError(error)
+        children: /* @__PURE__ */ jsx(Box, {
+            paddingTop: BANNER_LANE_INSET,
+            children: /* @__PURE__ */ jsx(NoteBanner, {
+                label: text,
+                tone: "critical"
+            })
         })
     });
 }
 
-function PageBody({board: board, catalogEmpty: catalogEmpty, error: error, loading: loading, page: page, selection: selection, wiring: wiring}) {
-    if (error !== void 0) /* @__PURE__ */ return jsx(CatalogErrorFace, {
-        error: error
+function PageBody({board: board, catalogEmpty: catalogEmpty, catalogError: catalogError, instancesError: instancesError, loading: loading, page: page, selection: selection, wiring: wiring}) {
+    if (catalogError !== void 0) /* @__PURE__ */ return jsx(ReadErrorFace, {
+        text: CATALOG_READ_FAILED
     });
     if (selection.kind === "unknown") {
         const face = unknownWorkflowFace({
@@ -3894,6 +4408,8 @@ function PageBody({board: board, catalogEmpty: catalogEmpty, error: error, loadi
     }
     return page === "definition" ? /* @__PURE__ */ jsx(DefinitionPanel, {
         definition: selection.definition
+    }) : instancesError !== void 0 ? /* @__PURE__ */ jsx(ReadErrorFace, {
+        text: INSTANCES_READ_FAILED
     }) : loading || board === void 0 ? /* @__PURE__ */ jsx(StatusBox, {
         children: /* @__PURE__ */ jsx(Box, {
             paddingTop: LANE_PADDING,
@@ -4058,10 +4574,12 @@ function WorkflowsHome({filterSlot: filterSlot, onOpenInstance: onOpenInstance,
 
 function HomePanel({filterSlot: filterSlot, identity: identity, instances: instances, onOpenInstance: onOpenInstance, onOpenTask: onOpenTask, onOpenWorkflow: onOpenWorkflow, tab: tab}) {
     return tab === "overview" ? /* @__PURE__ */ jsx(OverviewTab, {
+        identity: identity,
         onOpenWorkflow: onOpenWorkflow
     }) : /* @__PURE__ */ jsx(TasksTab, {
+        error: instances.error,
         filterSlot: filterSlot,
-        identity: identity,
+        identity: identityOf(identity),
         instances: [ ...instances.inFlight, ...instances.settled ],
         loading: instances.loading,
         onOpenInstance: onOpenInstance,