create-safest-tools 0.6.0 → 0.7.0

package/template/console/command/CommandCentre.tsx

@@ -1,71 +1,91 @@
 import { useSyncExternalStore } from "react";
 import { PageHeader } from "../components/PageHeader";
-import { getCommandSnapshot, subscribeToCommand } from "./store";
-import type { CommandAction, CommandMetricSnapshot, CommandQueueLoad, CommandRunSummary } from "./types";
-import { dispatchOpenReport } from "../reports/events";
+import { CaseEscalations } from '../operations/CaseEscalations';
+import { dispatchOpenReport, dispatchReportFilters } from "../reports/events";
 import { dispatchNavigation } from "../shell/events";
+import { compactDuration } from "./presentation";
+import { getCommandSnapshot, subscribeToCommand } from "./store";
+import type {
+  CommandAction,
+  CommandMetricSnapshot,
+  CommandQueueLoad,
+  CommandSystemHealth,
+  CommandStatusTone,
+} from "./types";
 
 function performAction(action: CommandAction): void {
   if (action.type === "report") dispatchOpenReport(action.reportId);
   else dispatchNavigation(action.view);
 }
 
-function formattedDate(value: string): string {
-  const date = new Date(value);
-  if (!Number.isFinite(date.getTime())) return "Today";
-  return new Intl.DateTimeFormat(undefined, { weekday: "long", day: "numeric", month: "long" }).format(date);
-}
-
-function greeting(value: string, firstName: string): string {
-  const hour = new Date(value).getHours();
-  const timeOfDay = hour < 12 ? "morning" : hour < 18 ? "afternoon" : "evening";
-  return `Good ${timeOfDay}, ${firstName || "there"}.`;
-}
-
-function EmptyProduct({ icon, title, description }: { icon: string; title: string; description: string }) {
-  return <div className="empty-product"><span aria-hidden="true">{icon}</span><h2>{title}</h2><p>{description}</p></div>;
+function EmptyReviewQueue() {
+  return (
+    <div className="command-empty">
+      <span aria-hidden="true"><svg viewBox="0 0 24 24"><circle cx="12" cy="12" r="9" /><path d="m8 12 2.5 2.5L16 9" /></svg></span>
+      <div><strong>Review queue is clear</strong><small>New reports will appear here as they are routed.</small></div>
+    </div>
+  );
 }
 
 function Metrics({ metrics, loading }: { metrics: CommandMetricSnapshot; loading: boolean }) {
-  const values = [
-    { label: "Open reports", detail: "Accepted allegations", icon: "i-inbox", value: metrics.openReports },
-    { label: "Needs a person", detail: "Unclaimed or waiting", icon: "i-user", value: metrics.needsHuman },
-    { label: "Workflow runs", detail: "Running or waiting", icon: "i-workflow", value: metrics.activeRuns },
-    { label: "Unresolved incidents", detail: "Waiting for repair", icon: "i-activity", value: metrics.unresolvedIncidents },
+  const openSummary = (label: string): void => {
+    dispatchReportFilters({ search: "", queueId: "", priority: label === "Urgent" ? "urgent" : "", age: "", state: "needs_review", sort: "priority", ownership: label === "Unassigned" ? "unassigned" : "" });
+    dispatchNavigation("reports");
+  };
+  const values: Array<{ label: string; value: number; detail: string; tone: CommandStatusTone }> = [
+    { label: "To review", value: metrics.awaitingReview, detail: "Ready for a decision", tone: metrics.awaitingReview ? "warning" : "positive" },
+    { label: "Urgent", value: metrics.urgent, detail: "Highest priority", tone: metrics.urgent ? "danger" : "positive" },
+    { label: "Unassigned", value: metrics.unassigned, detail: "Needs an owner", tone: metrics.unassigned ? "warning" : "positive" },
+    { label: "Reviewers online", value: metrics.onlineReviewers, detail: "Available now", tone: "neutral" },
   ];
   return (
-    <section className="metrics command-metrics" aria-label="Workspace summary" aria-busy={loading}>
+    <section className="command-signals" aria-label="Live review summary" aria-busy={loading}>
       {values.map((item) => (
-        <article key={item.label}><span>{item.label} <svg aria-hidden="true"><use href={`#${item.icon}`} /></svg></span><strong>{loading ? "—" : item.value}</strong><small>{item.detail}</small></article>
+        item.label === "Reviewers online" ? <article className={`command-signal ${item.tone}`} key={item.label}><span>{item.label}</span><strong>{loading ? "—" : item.value}</strong><small>{item.detail}</small></article> : <button className={`command-signal ${item.tone}`} type="button" key={item.label} onClick={() => openSummary(item.label)}>
+          <span>{item.label}</span><strong>{loading ? "—" : item.value}</strong><small>{item.detail}</small>
+        </button>
       ))}
     </section>
   );
 }
 
 function QueueLoadRow({ queue }: { queue: CommandQueueLoad }) {
-  const tone = queue.pressure >= 80 ? " danger" : queue.pressure >= 55 ? " warning" : "";
-  const width = Math.max(queue.openCount ? 8 : 0, queue.pressure);
+  const width = Math.max(queue.openCount ? 7 : 0, queue.pressure);
+  const target = queue.targetMinutes ? `${compactDuration(queue.targetMinutes)} response target` : "No response target";
+  const risk = queue.breachedCount
+    ? `${queue.breachedCount} overdue`
+    : queue.openCount ? `Oldest waiting ${compactDuration(queue.oldestMinutes)}` : "Queue is clear";
   return (
-    <article className="queue-load-row">
-      <div className="queue-load-label"><strong>{queue.name}</strong><small>{queue.targetMinutes}m first-response target</small></div>
-      <span className="queue-load-track" role="progressbar" aria-label={`${queue.name} response pressure`} aria-valuemin={0} aria-valuemax={100} aria-valuenow={queue.pressure}>
-        <i className={`queue-load-fill${tone}`} style={{ width: `${width}%` }} />
+    <article className={`queue-health-row ${queue.tone}`}>
+      <div className="queue-health-title"><strong>{queue.name}</strong><span>{queue.openCount} to review</span></div>
+      <div className="queue-health-meta"><span>{risk}</span><span>{queue.unassignedCount} unassigned</span></div>
+      <span className="queue-health-track" role="progressbar" aria-label={`${queue.name} response target usage`} aria-valuemin={0} aria-valuemax={100} aria-valuenow={queue.pressure}>
+        <i style={{ width: `${width}%` }} />
       </span>
-      <strong className="queue-load-count">{queue.openCount} open</strong>
+      <small>{target}</small>
     </article>
   );
 }
 
-function RunRow({ run }: { run: CommandRunSummary }) {
-  const tone = run.tone === "neutral" ? "" : ` ${run.tone}`;
+function SystemHealth({ health, canOpen }: { health: CommandSystemHealth; canOpen: boolean }) {
+  const healthy = health.issueCount === 0;
   return (
-    <article className="compact-run-row">
-      <span className="run-glyph" aria-hidden="true">⌘</span>
-      <div><strong>{run.title}</strong><small>{run.detail}</small></div>
-      <span className={`run-status${tone}`}>{run.status}</span>
-      <span className="run-age">{run.age}</span>
-      <button className="text-button run-open" type="button" onClick={() => performAction(run.action)}>Open</button>
-    </article>
+    <section className="surface command-panel system-health-panel">
+      <div className="surface-head">
+        <div><h2>System health</h2><p>Delivery and automation requiring intervention.</p></div>
+        {canOpen ? <button className="text-button" type="button" onClick={() => dispatchNavigation("operations")}>Open operations</button> : null}
+      </div>
+      <div className={`system-health-summary${healthy ? " healthy" : " danger"}`}>
+        <span aria-hidden="true"><svg viewBox="0 0 24 24">{healthy ? <><circle cx="12" cy="12" r="9" /><path d="m8 12 2.5 2.5L16 9" /></> : <><path d="M10.3 3.6 2.4 18a2 2 0 0 0 1.8 3h15.6a2 2 0 0 0 1.8-3L13.7 3.6a2 2 0 0 0-3.4 0z" /><path d="M12 9v4M12 17h.01" /></>}</svg></span>
+        <div><strong>{healthy ? "All systems healthy" : `${health.issueCount} system area${health.issueCount === 1 ? "" : "s"} need attention`}</strong><small>{healthy ? "No incidents, failed deliveries, or workflow repairs." : "Open Operations to acknowledge and recover affected work."}</small></div>
+      </div>
+      <dl className="system-health-facts">
+        <div><dt>Incidents</dt><dd>{health.incidentCount}</dd></div>
+        <div><dt>Delivery failures</dt><dd>{health.deliveryFailureCount}</dd></div>
+        <div><dt>Workflow repairs</dt><dd>{health.workflowIssueCount}</dd></div>
+        <div><dt>Active workflows</dt><dd>{health.activeRunCount}</dd></div>
+      </dl>
+    </section>
   );
 }
 
@@ -75,21 +95,20 @@ function LoadingRows() {
 
 export function CommandCentre() {
   const snapshot = useSyncExternalStore(subscribeToCommand, getCommandSnapshot, getCommandSnapshot);
-  const welcome = greeting(snapshot.generatedAt, snapshot.firstName);
-  const attentionSummary = snapshot.metrics.needsHuman
-    ? `${snapshot.metrics.needsHuman} item${snapshot.metrics.needsHuman === 1 ? "" : "s"} need attention.`
-    : "No reports or workflow issues need attention.";
+  const reviewCount = snapshot.metrics.awaitingReview;
+  const summary = snapshot.loading
+    ? "Loading the live review queue."
+    : reviewCount
+      ? `${reviewCount} case${reviewCount === 1 ? "" : "s"} awaiting review · oldest waiting ${compactDuration(snapshot.metrics.oldestWaitMinutes)}.`
+      : "The review queue is clear. New work will appear here automatically.";
+  const nextReport = snapshot.nextReview;
 
   return (
     <div data-react-slice="command-centre">
-      <PageHeader
-        className="command-head"
-        title="Command centre"
-        description={`${formattedDate(snapshot.generatedAt)} · ${welcome} ${snapshot.loading ? "Loading workspace status." : attentionSummary}`}
-      >
-        <div className="surface-buttons">
+      <PageHeader className="command-head" title="Today" description={summary}>
+        <div className="surface-buttons command-actions">
+          {nextReport ? <button className="primary" type="button" onClick={() => dispatchOpenReport(nextReport.reportId, true)}><svg aria-hidden="true"><use href="#i-inbox" /></svg>{nextReport.mine ? "Continue review" : "Review next"}</button> : null}
           {snapshot.permissions.useAssistant ? <button className="secondary command-assistant-action" type="button" onClick={() => dispatchNavigation("assistant")}><svg aria-hidden="true"><use href="#i-spark" /></svg>Ask Safest</button> : null}
-          {snapshot.permissions.manageWorkflows ? <button className="primary" type="button" onClick={() => dispatchNavigation("workflows")}><svg aria-hidden="true"><use href="#i-plus" /></svg>New workflow</button> : null}
         </div>
       </PageHeader>
 
@@ -98,22 +117,40 @@ export function CommandCentre() {
       ) : null}
 
       <Metrics metrics={snapshot.metrics} loading={snapshot.loading} />
+      <CaseEscalations compact />
 
-      <div className="command-grid">
-        <section className="surface command-panel"><div className="surface-head"><h2>Needs attention</h2><button className="text-button" type="button" onClick={() => dispatchNavigation("reports")}>View all</button></div><div className="attention-list" aria-busy={snapshot.loading}>
-          {snapshot.loading ? <LoadingRows /> : snapshot.attention.length ? snapshot.attention.map((item) => (
-            <button className="attention-row" type="button" key={item.id} onClick={() => performAction(item.action)}><span className={`attention-glyph${item.urgent ? " danger" : ""}`} aria-hidden="true">{item.icon}</span><span><strong>{item.title}</strong><small>{item.detail}</small></span><span className="attention-meta">{item.meta}</span></button>
-          )) : <EmptyProduct icon="✓" title="You’re all caught up" description="No reports or workflow issues need attention." />}
-        </div></section>
+      <div className="command-workspace-grid">
+        <section className="surface command-panel review-priority-panel">
+          <div className="surface-head">
+            <div><h2>Review queue</h2><p>Ordered by overdue target, priority, ownership, then age.</p></div>
+            <div className="surface-head-actions"><span className="live-label"><i />Live</span><button className="text-button" type="button" onClick={() => dispatchNavigation("reports")}>View all</button></div>
+          </div>
+          <div className="review-priority-list" aria-busy={snapshot.loading}>
+            {snapshot.loading ? <LoadingRows /> : snapshot.attention.length ? snapshot.attention.map((item) => (
+              <button className={`review-priority-row ${item.tone}`} type="button" key={item.id} onClick={() => performAction(item.action)}>
+                <i className="review-priority-rail" aria-hidden="true" />
+                <span className="review-priority-main">
+                  <span className="review-priority-title"><strong>{item.title}</strong><b className={`priority-chip ${item.tone}`}>{item.priorityLabel}</b></span>
+                  <small>{item.reference} · {item.queueName}</small>
+                  <span className="review-priority-meta"><span>{item.ownership}</span><span>Received {item.age}</span></span>
+                </span>
+                <span className={`sla-chip ${item.tone}`}>{item.slaLabel}</span>
+                <svg className="review-row-arrow" aria-hidden="true" viewBox="0 0 24 24"><path d="m9 6 6 6-6 6" /></svg>
+              </button>
+            )) : <EmptyReviewQueue />}
+          </div>
+        </section>
 
-        <section className="surface command-panel queue-load-panel"><div className="surface-head"><h2>Queue load</h2><span className="live-label"><i />Live</span></div><div className="queue-load-list" aria-busy={snapshot.loading}>
-          {snapshot.loading ? <LoadingRows /> : snapshot.queueLoads.length ? snapshot.queueLoads.map((queue) => <QueueLoadRow queue={queue} key={queue.id} />) : <EmptyProduct icon="≋" title="Queue load unavailable" description="Your role does not include queue load data." />}
-        </div></section>
+        <div className="command-side-stack">
+          <section className="surface command-panel queue-health-panel">
+            <div className="surface-head"><div><h2>Queue health</h2><p>Current wait against each first-response target.</p></div></div>
+            <div className="queue-health-list" aria-busy={snapshot.loading}>
+              {snapshot.loading ? <LoadingRows /> : snapshot.queueLoads.length ? snapshot.queueLoads.map((queue) => <QueueLoadRow queue={queue} key={queue.id} />) : <div className="command-empty compact"><div><strong>No active queues</strong><small>Published queues will appear here.</small></div></div>}
+            </div>
+          </section>
+          <SystemHealth health={snapshot.systemHealth} canOpen={snapshot.permissions.viewAudit} />
+        </div>
       </div>
-
-      <section className="surface command-panel recent-runs-panel"><div className="surface-head"><h2>Recent workflow runs</h2>{snapshot.permissions.viewAudit ? <button className="text-button" type="button" onClick={() => dispatchNavigation("operations")}>View runs</button> : null}</div><div className="compact-run-list" aria-busy={snapshot.loading}>
-        {snapshot.loading ? <LoadingRows /> : snapshot.recentRuns.length ? snapshot.recentRuns.map((run) => <RunRow run={run} key={run.id} />) : <EmptyProduct icon="⌘" title="No recent runs" description="Runs appear here when a report starts a workflow." />}
-      </div></section>
     </div>
   );
 }

package/template/console/command/controller.ts

@@ -1,4 +1,6 @@
+import { loadInbox } from "../reports/load-inbox";
 import { requestJson } from "../lib/http";
+import { readable, relativeTime } from "../lib/format";
 import { getOperationsWorkspaceSnapshot, subscribeToOperationsWorkspace } from "../operations/store";
 import { getQueueWorkspaceSnapshot, subscribeToQueueWorkspace } from "../queues/store";
 import type { QueueRecord } from "../queues/types";
@@ -6,8 +8,9 @@ import { getReportWorkspaceSnapshot, subscribeToReportWorkspace } from "../repor
 import { settingsEvents } from "../settings/events";
 import type { SetupStatus } from "../settings/types";
 import { getShellSnapshot, subscribeToShell } from "../shell/store";
+import { priorityLabel, slaStatus } from "./presentation";
 import { setCommandSnapshot } from "./store";
-import type { CommandAttentionItem, CommandQueueLoad, CommandRunSummary, CommandSnapshot } from "./types";
+import type { CommandAttentionItem, CommandQueueLoad, CommandSnapshot } from "./types";
 
 interface CommandReport {
   id: string;
@@ -17,7 +20,7 @@ interface CommandReport {
   state: string;
   priority: number;
   receivedAt: string;
-  claim?: { reviewerId?: string } | null;
+  assignment?: { reviewerId?: string; analyst?: { displayName?: string } } | null;
 }
 
 interface WorkflowRun {
@@ -32,12 +35,13 @@ interface WorkflowRun {
   createdAt: string;
 }
 
-interface ReportsResponse { reports?: CommandReport[] }
 interface QueuesResponse { queues?: QueueRecord[] }
 interface WorkflowRunsResponse { runs?: WorkflowRun[] }
 
 const closedReportStates = new Set(["resolved_by_human", "resolved_by_ai", "closed"]);
+const reviewReportStates = new Set(["human_review", "human_review_requested"]);
 const activeRunStates = new Set(["created", "dispatch_pending", "queued", "running", "waiting", "paused"]);
+const unhealthyRunStates = new Set(["failed", "repair_required"]);
 
 let actorId = "";
 let reports: CommandReport[] = [];
@@ -51,7 +55,7 @@ let refreshScheduled = false;
 let started = false;
 
 function reportDataSignature(): string {
-  return reports.map((report) => `${report.id}:${report.state}:${report.priority}:${report.claim?.reviewerId || ""}`).sort().join("|");
+  return reports.map((report) => `${report.id}:${report.state}:${report.priority}:${report.assignment?.reviewerId || ""}`).sort().join("|");
 }
 
 function reportStoreSignature(): string {
@@ -72,23 +76,9 @@ function queueStoreSignature(): string {
     .join("|");
 }
 
-function readable(value: string): string {
-  const copy = value.replaceAll("_", " ");
-  if (!copy) return "";
-  const sentence = `${copy.charAt(0).toUpperCase()}${copy.slice(1)}`;
-  const acronyms: Record<string, string> = { ai: "AI", api: "API", csv: "CSV", d1: "D1", http: "HTTP", https: "HTTPS", id: "ID", json: "JSON", r2: "R2", sla: "SLA", url: "URL" };
-  return sentence.replace(/\b(ai|api|csv|d1|http|https|id|json|r2|sla|url)\b/giu, (match) => acronyms[match.toLowerCase()] ?? match);
-}
-
-function relativeTime(value: string | undefined): string {
-  const milliseconds = Date.now() - Date.parse(value || "");
-  if (!Number.isFinite(milliseconds)) return "Unknown";
-  const minutes = Math.max(0, Math.floor(milliseconds / 60_000));
-  if (minutes < 1) return "Just now";
-  if (minutes < 60) return `${minutes}m ago`;
-  const hours = Math.floor(minutes / 60);
-  if (hours < 48) return `${hours}h ago`;
-  return `${Math.floor(hours / 24)}d ago`;
+function reportAgeMinutes(report: CommandReport): number {
+  const receivedAt = Date.parse(report.receivedAt);
+  return Number.isFinite(receivedAt) ? Math.max(0, (Date.now() - receivedAt) / 60_000) : 0;
 }
 
 function reset(): void {
@@ -104,78 +94,97 @@ function reset(): void {
 function buildSnapshot(): CommandSnapshot {
   const session = getShellSnapshot().session;
   const openReports = reports.filter((report) => !closedReportStates.has(report.state));
-  const needsHuman = openReports.filter((report) => !report.claim || ["human_review", "waiting_for_human", "awaiting_reporter"].includes(report.state));
+  const needsHuman = openReports.filter((report) => reviewReportStates.has(report.state));
   const activeRuns = runs.filter((run) => activeRunStates.has(run.state));
+  const workflowIssueCount = runs.filter((run) => unhealthyRunStates.has(run.state)).length;
   const operations = getOperationsWorkspaceSnapshot().operations;
   const incidentCount = Number(operations?.incidents.open || 0) + Number(operations?.incidents.acknowledged || 0);
-  const displayName = session?.displayName || "there";
+  const deliveryFailureCount = Number(operations?.routing.failed || 0)
+    + Number(operations?.routing.deadLetter || 0)
+    + Number(operations?.actions.terminalFailed || 0)
+    + Number(operations?.notifications.terminalFailed || 0)
+    + Number(operations?.emails.terminalFailed || 0);
+  const queueById = new Map(queues.map((queue) => [queue.id, queue]));
+  const sortedAttention = [...needsHuman].sort((left, right) => {
+    const leftTarget = queueById.get(left.queueId || "")?.activePolicy?.responseSlaMinutes ?? null;
+    const rightTarget = queueById.get(right.queueId || "")?.activePolicy?.responseSlaMinutes ?? null;
+    const leftBreached = slaStatus(reportAgeMinutes(left), leftTarget).breached;
+    const rightBreached = slaStatus(reportAgeMinutes(right), rightTarget).breached;
+    if (leftBreached !== rightBreached) return leftBreached ? -1 : 1;
+    if (left.priority !== right.priority) return right.priority - left.priority;
+    if (Boolean(left.assignment) !== Boolean(right.assignment)) return left.assignment ? 1 : -1;
+    return Date.parse(left.receivedAt) - Date.parse(right.receivedAt);
+  });
 
-  const attention: CommandAttentionItem[] = needsHuman.slice(0, 4).map((report) => ({
-    id: `report-${report.id}`,
-    icon: report.priority >= 80 ? "!" : "⌁",
-    title: `${report.reasonCode ? readable(report.reasonCode) : "Report"} needs review`,
-    detail: `${report.reference} · ${queues.find((queue) => queue.id === report.queueId)?.name || "Unrouted"} · ${relativeTime(report.receivedAt)}`,
-    meta: report.claim ? "Claimed" : "Unclaimed",
-    urgent: report.priority >= 80,
-    action: { type: "report", reportId: report.id },
-  }));
-  if (incidentCount > 0) attention.push({
-    id: "operations-incidents",
-    icon: "◇",
-    title: "Operations work needs attention",
-    detail: "An unresolved operational incident needs acknowledgement or recovery.",
-    meta: `${incidentCount} open`,
-    urgent: true,
-    action: { type: "view", view: "operations" },
+  const attention: CommandAttentionItem[] = sortedAttention.slice(0, 6).map((report) => {
+    const queue = queueById.get(report.queueId || "");
+    const sla = slaStatus(reportAgeMinutes(report), queue?.activePolicy?.responseSlaMinutes ?? null);
+    return {
+      id: `report-${report.id}`,
+      title: `${report.reasonCode ? readable(report.reasonCode) : "Safety"} report`,
+      reference: report.reference,
+      queueName: queue?.name || "Unrouted",
+      age: relativeTime(report.receivedAt),
+      ownership: report.assignment ? (report.assignment.reviewerId === actorId ? "Assigned to you" : `Assigned to ${report.assignment.analyst?.displayName || "another reviewer"}`) : "Unassigned",
+      priorityLabel: priorityLabel(report.priority),
+      slaLabel: sla.label,
+      tone: report.priority >= 80 ? "danger" : sla.tone,
+      action: { type: "report", reportId: report.id },
+    };
   });
 
-  const queueLoads: CommandQueueLoad[] = queues.filter((queue) => queue.status === "active").slice(0, 5).map((queue) => {
-    const queuedReports = openReports.filter((report) => report.queueId === queue.id);
-    const targetMinutes = Number(queue.activePolicy?.responseSlaMinutes || 60);
-    const oldest = queuedReports.reduce((value, report) => Math.min(value, Date.parse(report.receivedAt)), Date.now());
-    const ageMinutes = queuedReports.length ? Math.max(0, (Date.now() - oldest) / 60_000) : 0;
+  const queueLoads: CommandQueueLoad[] = queues.filter((queue) => queue.status === "active").map((queue): CommandQueueLoad => {
+    const queuedReports = needsHuman.filter((report) => report.queueId === queue.id);
+    const targetMinutes = queue.activePolicy?.responseSlaMinutes ?? null;
+    const ages = queuedReports.map(reportAgeMinutes);
+    const oldestMinutes = ages.length ? Math.max(...ages) : 0;
+    const breachedCount = ages.filter((age) => slaStatus(age, targetMinutes).breached).length;
+    const pressure = targetMinutes ? Math.min(100, Math.round((oldestMinutes / Math.max(1, targetMinutes)) * 100)) : 0;
     return {
       id: queue.id,
       name: queue.name,
       targetMinutes,
       openCount: queuedReports.length,
-      pressure: Math.min(100, Math.round((ageMinutes / Math.max(1, targetMinutes)) * 100)),
-    };
-  });
-
-  const recentRuns: CommandRunSummary[] = runs.slice(0, 5).map((run) => {
-    const report = reports.find((candidate) => candidate.id === run.reportId);
-    const waitingForHuman = Number(run.openTaskCount || 0) > 0;
-    return {
-      id: run.id,
-      title: run.workflowName || run.workflowKey || `Run ${run.id.slice(0, 8)}`,
-      detail: `${report?.reference || run.reportId || "Report"} · v${run.version || "—"}`,
-      status: waitingForHuman ? "Waiting for human" : readable(run.state),
-      tone: run.state === "failed" || run.state === "repair_required" ? "danger" : waitingForHuman || run.state === "waiting" ? "warning" : "neutral",
-      age: relativeTime(run.startedAt || run.createdAt).replace(" ago", ""),
-      action: run.reportId ? { type: "report", reportId: run.reportId } : { type: "view", view: "operations" },
+      unassignedCount: queuedReports.filter((report) => !report.assignment).length,
+      oldestMinutes,
+      breachedCount,
+      pressure,
+      tone: breachedCount ? "danger" : pressure >= 75 ? "warning" : "positive",
     };
-  });
+  }).sort((left, right) => right.breachedCount - left.breachedCount || right.pressure - left.pressure || right.openCount - left.openCount).slice(0, 5);
 
   const optionalSetup = new Set(setup?.optional || []);
   const incompleteSetupCount = setup?.features.filter((feature) => feature.state !== "ready" && !optionalSetup.has(feature.featureKey)).length || 0;
+  const unassigned = needsHuman.filter((report) => !report.assignment).length;
+  const urgent = needsHuman.filter((report) => report.priority >= 80).length;
+  const oldestWaitMinutes = needsHuman.length ? Math.max(...needsHuman.map(reportAgeMinutes)) : 0;
+  const systemIssueCount = Number(incidentCount > 0) + Number(workflowIssueCount > 0) + Number(deliveryFailureCount > 0);
   return {
     loading,
     generatedAt: new Date().toISOString(),
-    firstName: displayName.split(" ")[0] || "there",
     metrics: {
-      openReports: openReports.length,
-      needsHuman: needsHuman.length,
-      activeRuns: activeRuns.length,
-      unresolvedIncidents: incidentCount,
+      awaitingReview: needsHuman.length,
+      urgent,
+      unassigned,
+      onlineReviewers: getReportWorkspaceSnapshot().presence.length,
+      oldestWaitMinutes,
     },
     attention,
+    nextReview: session?.permissions.claimReports ? (() => {
+      const next = sortedAttention.find(report => report.assignment?.reviewerId === actorId) || sortedAttention.find(report => !report.assignment);
+      return next ? { reportId: next.id, mine: next.assignment?.reviewerId === actorId } : null;
+    })() : null,
     queueLoads,
-    recentRuns,
+    systemHealth: {
+      issueCount: systemIssueCount,
+      incidentCount,
+      workflowIssueCount,
+      deliveryFailureCount,
+      activeRunCount: activeRuns.length,
+    },
     incompleteSetupCount,
     permissions: {
       useAssistant: session?.permissions.useAssistant === true,
-      manageWorkflows: session?.permissions.manageWorkflows === true,
       viewAudit: session?.permissions.viewAudit === true,
       manageInstallation: session?.permissions.manageInstallation === true,
     },
@@ -196,8 +205,8 @@ async function loadCommandData(): Promise<void> {
   loading = true;
   publish();
   const tasks: Promise<void>[] = [
-    requestJson<ReportsResponse>("/v1/admin/reports?limit=100")
-      .then((response) => { reports = response.reports || []; })
+    loadInbox<CommandReport>()
+      .then((response) => { reports = response; })
       .catch(() => { reports = []; }),
     requestJson<QueuesResponse>(`/v1/admin/queues${session.permissions.manageConfiguration ? "?include_archived=true" : ""}`)
       .then((response) => { queues = response.queues || []; })
@@ -250,6 +259,7 @@ export function startCommandController(): void {
       reportSignature = signature;
       scheduleRefresh();
     }
+    publish();
   });
   subscribeToQueueWorkspace(() => {
     const snapshot = getQueueWorkspaceSnapshot();

package/template/console/command/events.ts

@@ -9,11 +9,10 @@ export function isCommandSnapshot(value: unknown): value is CommandSnapshot {
   const candidate = value as Partial<CommandSnapshot>;
   return typeof candidate.loading === "boolean"
     && typeof candidate.generatedAt === "string"
-    && typeof candidate.firstName === "string"
     && typeof candidate.metrics === "object"
     && Array.isArray(candidate.attention)
     && Array.isArray(candidate.queueLoads)
-    && Array.isArray(candidate.recentRuns)
+    && typeof candidate.systemHealth === "object"
     && typeof candidate.incompleteSetupCount === "number"
     && typeof candidate.permissions === "object";
 }

package/template/console/command/presentation.ts

@@ -0,0 +1,29 @@
+import type { CommandStatusTone } from "./types";
+export { priorityLabel } from "../lib/priority";
+
+export function compactDuration(minutes: number): string {
+  const rounded = Math.max(0, Math.floor(minutes));
+  if (rounded < 1) return "now";
+  if (rounded < 60) return `${rounded}m`;
+  const hours = Math.floor(rounded / 60);
+  if (hours < 48) return `${hours}h`;
+  return `${Math.floor(hours / 24)}d`;
+}
+
+export function slaStatus(ageMinutes: number, targetMinutes: number | null): {
+  label: string;
+  tone: CommandStatusTone;
+  breached: boolean;
+} {
+  if (!targetMinutes || targetMinutes <= 0) {
+    return { label: `${compactDuration(ageMinutes)} waiting`, tone: "neutral", breached: false };
+  }
+  const remaining = targetMinutes - ageMinutes;
+  if (remaining <= 0) {
+    return { label: `${compactDuration(Math.abs(remaining))} overdue`, tone: "danger", breached: true };
+  }
+  if (remaining <= Math.max(15, targetMinutes * .25)) {
+    return { label: `${compactDuration(remaining)} to target`, tone: "warning", breached: false };
+  }
+  return { label: `${compactDuration(remaining)} to target`, tone: "positive", breached: false };
+}

package/template/console/command/store.ts

@@ -6,13 +6,13 @@ const subscribers = new Set<() => void>();
 let snapshot: CommandSnapshot = {
   loading: true,
   generatedAt: new Date().toISOString(),
-  firstName: "there",
-  metrics: { openReports: 0, needsHuman: 0, activeRuns: 0, unresolvedIncidents: 0 },
+  metrics: { awaitingReview: 0, urgent: 0, unassigned: 0, onlineReviewers: 0, oldestWaitMinutes: 0 },
   attention: [],
+  nextReview: null,
   queueLoads: [],
-  recentRuns: [],
+  systemHealth: { issueCount: 0, incidentCount: 0, workflowIssueCount: 0, deliveryFailureCount: 0, activeRunCount: 0 },
   incompleteSetupCount: 0,
-  permissions: { useAssistant: false, manageWorkflows: false, viewAudit: false, manageInstallation: false },
+  permissions: { useAssistant: false, viewAudit: false, manageInstallation: false },
 };
 
 window.addEventListener(commandEvents.state, (event) => {

package/template/console/command/types.ts

@@ -1,61 +1,66 @@
 import type { WorkspaceView } from "../shell/types";
 
-export type CommandStatusTone = "neutral" | "warning" | "danger";
+export type CommandStatusTone = "neutral" | "positive" | "warning" | "danger";
 
 export type CommandAction =
   | { type: "report"; reportId: string }
   | { type: "view"; view: WorkspaceView };
 
 export interface CommandMetricSnapshot {
-  openReports: number;
-  needsHuman: number;
-  activeRuns: number;
-  unresolvedIncidents: number;
+  awaitingReview: number;
+  urgent: number;
+  unassigned: number;
+  onlineReviewers: number;
+  oldestWaitMinutes: number;
 }
 
 export interface CommandAttentionItem {
   id: string;
-  icon: string;
   title: string;
-  detail: string;
-  meta: string;
-  urgent: boolean;
+  reference: string;
+  queueName: string;
+  age: string;
+  ownership: string;
+  priorityLabel: string;
+  slaLabel: string;
+  tone: CommandStatusTone;
   action: CommandAction;
 }
 
 export interface CommandQueueLoad {
   id: string;
   name: string;
-  targetMinutes: number;
+  targetMinutes: number | null;
   openCount: number;
+  unassignedCount: number;
+  oldestMinutes: number;
+  breachedCount: number;
   pressure: number;
+  tone: CommandStatusTone;
 }
 
-export interface CommandRunSummary {
-  id: string;
-  title: string;
-  detail: string;
-  status: string;
-  tone: CommandStatusTone;
-  age: string;
-  action: CommandAction;
+export interface CommandSystemHealth {
+  issueCount: number;
+  incidentCount: number;
+  workflowIssueCount: number;
+  deliveryFailureCount: number;
+  activeRunCount: number;
 }
 
 export interface CommandPermissions {
   useAssistant: boolean;
-  manageWorkflows: boolean;
   viewAudit: boolean;
   manageInstallation: boolean;
 }
 
 export interface CommandSnapshot {
+  nextReview: { reportId: string; mine: boolean } | null;
   loading: boolean;
   generatedAt: string;
-  firstName: string;
   metrics: CommandMetricSnapshot;
   attention: CommandAttentionItem[];
   queueLoads: CommandQueueLoad[];
-  recentRuns: CommandRunSummary[];
+  systemHealth: CommandSystemHealth;
   incompleteSetupCount: number;
   permissions: CommandPermissions;
 }