create-safest-tools 0.6.0 → 0.6.1

package/README.md

@@ -18,7 +18,7 @@ npx create-safest-tools safest-resolve \
   --email-from reports@example.com
 ```
 
-The `--email-from` address is a real, receivable mailbox used for receipts, follow-ups, outcomes, and replies from reporters or affected users. Use a short base address such as `reports@example.com` on a domain onboarded under Cloudflare Email Service → Email Sending, then enable Email Routing for that domain. Setup creates an exact Worker route for this address, enables plus-addressing for signed case replies, and does not enable catch-all mail. Account verification, invitations, and password recovery use a distinct `accounts@` address on the same domain by default; pass `--auth-email-from` to choose another address. Every customer-facing email automatically uses the organization name, logo, colors, type, and spacing saved under Configuration → Branding.
+The `--email-from` address is a real, receivable mailbox used for receipts, follow-ups, outcomes, and replies from reporters or affected users. Use a short base address such as `reports@example.com` on a domain onboarded under Cloudflare Email Service → Email Sending, then enable Email Routing for that domain. Setup creates an exact Worker route for this address, enables plus-addressing for signed case replies, and does not enable catch-all mail. Account verification, invitations, and password recovery use a distinct `accounts@` address on the same domain by default; pass `--auth-email-from` to choose another address. Every customer-facing email automatically uses the organization name, logo, colors, type, and spacing saved under Settings → Branding.
 
 The command creates a local project and prints a read-only infrastructure plan. It does not change Cloudflare unless `--deploy` is supplied or the generated project’s `npm run setup` command is run and explicitly confirmed.
 
@@ -46,7 +46,7 @@ npm run setup
 
 `setup:plan` lists exact resource names and the reporter email route, then exits without modifying Cloudflare. `setup` opens Wrangler's Cloudflare login when needed, lets you choose the owning account, and verifies Workers Paid from the account's Workers usage model. Standard accounts need no separate billing token; only legacy or ambiguous account models use the temporary Billing Read fallback. It then guides Google, GitHub, and Cloudflare OAuth configuration with exact callback URLs and masked secret input. Nothing is provisioned until the exact `DEPLOY <installation-id>` confirmation. After confirmation it verifies Email Routing, enables subaddressing, and deploys only the exact reporter-address route. If Cloudflare interrupts the deployment, run `npm run setup` again; it detects the unfinished installation, reuses the saved authentication choices and exact resources, suppresses expected already-exists errors, and continues through the owner-link step.
 
-A new installation applies one current D1 schema baseline. Later releases add only forward-compatible upgrade migrations.
+A new 0.6.1 installation applies one current D1 schema baseline. Later releases add only forward-compatible upgrade migrations. Because 0.6.1 replaces the earlier development migration chain with that baseline, the updater refuses to modify a deployed pre-0.6.1 project in place. Back up that deployment and create a separately named installation instead. Undeployed scaffolds may cross the boundary normally.
 
 After deployment, setup prints a 256-bit, single-use owner link that expires after 15 minutes. The raw token stays in the URL fragment, D1 stores only its digest, and the installer never writes it to disk. Open it to create the Safest owner account. If it expires, run `npm run owner:setup`. For later break-glass recovery, authenticate Wrangler and run `npm run owner:recover`.
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-safest-tools",
-  "version": "0.6.0",
+  "version": "0.6.1",
   "description": "Create customer-owned abuse-reporting infrastructure on Cloudflare",
   "type": "module",
   "license": "Apache-2.0",

package/src/update.mjs

@@ -6,6 +6,7 @@ import { buildWranglerConfiguration } from "./config.mjs";
 
 const MANIFEST_PATH = ".safest-managed.json";
 const MANIFEST_SCHEMA_VERSION = 1;
+const FRESH_SCHEMA_BASELINE_VERSION = "0.6.1";
 const REBUILDABLE_PATHS = new Set(["public/console/auth-shell.js"]);
 const CUSTOMER_RUNTIME_VAR_KEYS = new Set([
   "ALLOWED_ACTION_CODES",
@@ -185,6 +186,15 @@ export async function planProjectUpdate({ directory, templateDirectory }) {
   if (compareVersions(targetVersion, manifest.installedVersion) < 0) {
     throw new Error(`refusing to downgrade Safest Resolve from ${manifest.installedVersion} to ${targetVersion}`);
   }
+  const deployed = (currentWrangler.d1_databases ?? []).some(({ database_id: id }) => typeof id === "string" && id.length > 0);
+  if (deployed
+    && compareVersions(manifest.installedVersion, FRESH_SCHEMA_BASELINE_VERSION) < 0
+    && compareVersions(targetVersion, FRESH_SCHEMA_BASELINE_VERSION) >= 0) {
+    throw new Error(
+      `Safest Resolve ${FRESH_SCHEMA_BASELINE_VERSION} starts a new fresh-install schema lineage. `
+      + `Back up this ${manifest.installedVersion} deployment, then create and verify a separately named installation instead of updating it in place.`,
+    );
+  }
 
   const added = [];
   const updated = [];
@@ -205,7 +215,6 @@ export async function planProjectUpdate({ directory, templateDirectory }) {
   if (!wranglerMatchesManifest(currentWrangler, manifest.wranglerHash)) conflicts.push("wrangler.jsonc");
 
   const desiredWrangler = mergeWranglerRuntimeState(buildWranglerConfiguration(reportsConfiguration), currentWrangler);
-  const deployed = (currentWrangler.d1_databases ?? []).some(({ database_id: id }) => typeof id === "string" && id.length > 0);
   const uniqueConflicts = [...new Set(conflicts)].sort();
   return {
     action: "update",

package/template/README.md

@@ -14,7 +14,7 @@ Before deployment:
 4. Type the exact installation confirmation when setup requests it. After deployment, setup prints a 256-bit, single-use owner link that expires after 15 minutes and is never written to disk.
 5. Open the owner link, create the Safest owner account, then invite administrators and analysts from People. Nobody needs a Cloudflare account to sign in. Names and workspace roles are always displayed separately.
 
-Setup creates D1, four private R2 buckets, and three Queues, applies one current D1 schema baseline, and deploys the Worker with Dynamic Workflows. Later releases add only forward-compatible upgrade migrations. After owner setup, verify the `database`, `workflow_runtime`, `workers_ai`, `object_storage`, and `queues` setup features, then require an authenticated `GET /ready` response of 200. Public `GET /health` is liveness only. Better Auth owns password hashing, OAuth accounts, sessions, and one-time password-reset tokens in D1. Upgrades always back up D1 before migrations and deployment.
+Setup creates D1, four private R2 buckets, and three Queues, applies the current fresh-install D1 baseline, and deploys the Worker with Dynamic Workflows. Version 0.6.1 begins this schema lineage; the updater blocks deployed pre-0.6.1 projects from crossing it in place and directs operators to a verified backup plus separately named installation. Later releases add only forward-compatible migrations. After owner setup, verify the `database`, `workflow_runtime`, `workers_ai`, `object_storage`, and `queues` setup features, then require an authenticated `GET /ready` response of 200. Public `GET /health` is liveness only. Better Auth owns password hashing, OAuth accounts, sessions, and one-time password-reset tokens in D1. Upgrades always back up D1 before migrations and deployment.
 
 If the setup link expires, run `npm run owner:setup`. If the owner loses access later, authenticate Wrangler as the Cloudflare account owner and run `npm run owner:recover`; the resulting single-use link creates a 12-hour break-glass session and is recorded in the audit log.
 

package/template/console/README.md

@@ -6,10 +6,10 @@ The console uses React, TypeScript, and Vite. Each product area keeps its DOM, t
 
 - **Account access:** sign-in, infrastructure-owner bootstrap, password reset, invitation acceptance, and optional profile-picture upload.
 - **Workspace shell:** header, responsive navigation, current route, health, analyst identity, and permission-aware navigation.
-- **Command centre:** metrics, work that needs attention, queue pressure, recent workflow runs, and setup actions.
+- **Command centre:** an SLA-aware review queue, reviewer availability, queue health, operational health, and the next best action.
 - **Reports and appeals:** queue filters, presence, claims, participant messages, decisions, delivery history, workflow evidence, and separate appeal ownership.
 - **Queues and workflows:** queue policy publication, routing rollout, workflow drafts, graph editing, checks, fixture tests, publishing, and queue pins.
-- **Components and configuration:** component and connection records, outbound allowlists, intake forms, routing rules, decision policies, message templates, and the visual form builder.
+- **Tools, connections, and configuration:** reusable workflow capabilities, governed outbound routes, intake forms, routing rules, decision policies, message templates, and the visual form builder. Runtime APIs and database tables retain the stable `component` name for backward compatibility.
 - **Operations and quality:** AI samples, reviewer corrections, incidents, retries, dead-letter evidence, analytics, audit verification, and CSV export.
 - **People and settings:** invitations, password-reset emails, roles, personal profiles, deployment checks, branding, and reporting channels.
 - **Ask Safest:** scoped conversations, citations, read-only activity, and links back to reports.

package/template/console/command/CommandCentre.tsx

@@ -1,71 +1,86 @@
 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 { 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 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>
+        <button className={`command-signal ${item.tone}`} type="button" key={item.label} onClick={() => dispatchNavigation("reports")}>
+          <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 +90,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} report${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.attention[0];
 
   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="Command centre" description={summary}>
+        <div className="surface-buttons command-actions">
+          {nextReport ? <button className="primary" type="button" onClick={() => performAction(nextReport.action)}><svg aria-hidden="true"><use href="#i-inbox" /></svg>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>
 
@@ -99,21 +113,38 @@ export function CommandCentre() {
 
       <Metrics metrics={snapshot.metrics} loading={snapshot.loading} />
 
-      <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,5 @@
 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 +7,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;
@@ -37,7 +39,9 @@ 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[] = [];
@@ -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,93 @@ 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.claim) !== Boolean(right.claim)) return left.claim ? 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.claim ? "Assigned" : "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.claim).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.claim).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,
     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,
     },
@@ -250,6 +255,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,34 @@
+import type { CommandStatusTone } from "./types";
+
+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 priorityLabel(priority: number): string {
+  if (priority >= 80) return "Urgent";
+  if (priority >= 60) return "High";
+  return "Standard";
+}
+
+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,12 @@ 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: [],
   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) => {