@alexkroman1/aai-cli 6.10.1 → 7.0.0

package/dist/templates/dispatch-center/client.tsx

@@ -1,11 +1,12 @@
 import "@alexkroman1/aai-ui/styles.css";
-import type { AgentState, ChatMessage } from "@alexkroman1/aai-ui";
+import type { AgentState, ConversationItem } from "@alexkroman1/aai-ui";
 import {
   AutoScroll,
   client,
   useAgentState,
+  useConversation,
   useSession,
-  useUserTranscript,
+  useSessionSelector,
 } from "@alexkroman1/aai-ui";
 import type { DispatchState, IncidentSummary, Severity, Status } from "./shared.ts";
 import { dashboardProjection } from "./shared.ts";
@@ -139,15 +140,242 @@ function IncidentCard({ inc }: { inc: IncidentSummary }) {
   );
 }
 
-function App() {
+/** One radio line: a message bubble, or the tool call that came after it. */
+function Row({ item }: { item: ConversationItem }) {
+  if (item.kind === "tool") {
+    const { name, status } = item.toolCall;
+    return (
+      <div
+        className="self-start rounded-md px-2.5 py-1.5 text-[11px] font-mono flex items-center gap-2"
+        style={{
+          background: "#111827",
+          border: "1px solid #1e293b",
+          color: status === "pending" ? "#eab308" : "#64748b",
+        }}
+      >
+        <span
+          className="w-1.5 h-1.5 rounded-full inline-block"
+          style={{
+            background: status === "pending" ? "#eab308" : "#22c55e",
+            animation: status === "pending" ? "dc-pulse 1s ease-in-out infinite" : "none",
+          }}
+        />
+        {name}
+      </div>
+    );
+  }
+  const { role, content } = item.message;
+  return (
+    <div
+      className="rounded-lg text-[13px] max-w-[85%] px-3.5 py-2.5"
+      style={{
+        lineHeight: 1.6,
+        alignSelf: role === "assistant" ? "flex-start" : "flex-end",
+        background: role === "assistant" ? "#1e293b" : "#172554",
+        animation: "dc-slide-in 0.2s ease-out",
+        borderLeft: role === "assistant" ? "3px solid #3b82f6" : "none",
+        borderRight: role !== "assistant" ? "3px solid #22d3ee" : "none",
+      }}
+    >
+      <div className="text-[10px] uppercase tracking-wider mb-1" style={{ color: "#64748b" }}>
+        {role === "assistant" ? "DISPATCH" : "OPERATOR"}
+      </div>
+      {content}
+    </div>
+  );
+}
+
+/**
+ * The radio log.
+ *
+ * `useConversation()` rather than a `session.messages.map(...)`: the messages
+ * were only half of it. This board runs eight tools and rendered NONE of them,
+ * because tool calls live in a second array this page never read — and it also
+ * dropped the streaming reply and the thinking indicator. The hook owns the
+ * interleave (a tool row follows its anchor message), the `null`-vs-`""`
+ * transcript distinction and the thinking-suppression rule; what stays here is
+ * the markup, which is the part this template exists to show.
+ *
+ * It also subscribes per FIELD, so the conversation re-renders at the
+ * conversation's rate. The whole-page `useSession()` this replaced re-rendered
+ * the incident board on every STT partial.
+ */
+function Conversation() {
+  const { items, streaming, transcript, thinking } = useConversation();
+  return (
+    <>
+      <AutoScroll
+        scrollClassName="dc-messages overflow-y-auto"
+        contentClassName="p-4 flex flex-col gap-2"
+      >
+        {items.length === 0 && !streaming && (
+          <div className="text-center p-10 text-[13px]" style={{ color: "#475569" }}>
+            Dispatch Command Center standing by. Click START to begin operations.
+          </div>
+        )}
+        {items.map((item) => (
+          <Row
+            key={item.kind === "message" ? `m${item.message.id}` : item.toolCall.callId}
+            item={item}
+          />
+        ))}
+        {streaming !== null && (
+          <div
+            className="rounded-lg text-[13px] max-w-[85%] px-3.5 py-2.5 self-start"
+            style={{ lineHeight: 1.6, background: "#1e293b", borderLeft: "3px solid #3b82f6" }}
+          >
+            <div className="text-[10px] uppercase tracking-wider mb-1" style={{ color: "#64748b" }}>
+              DISPATCH
+            </div>
+            {streaming}
+          </div>
+        )}
+        {thinking && (
+          <div className="self-start text-[11px] px-3.5" style={{ color: "#64748b" }}>
+            <span style={{ animation: "dc-pulse 1.2s ease-in-out infinite" }}>· · ·</span>
+          </div>
+        )}
+      </AutoScroll>
+
+      {transcript.speaking && (
+        <div
+          className="flex items-center px-4 py-2 text-xs italic min-h-8"
+          style={{ background: "#111827", borderTop: "1px solid #1e293b", color: "#64748b" }}
+        >
+          <span
+            className="w-2.5 h-2.5 rounded-full inline-block mr-2"
+            style={{ background: "#22c55e", animation: "dc-pulse 1.5s ease-in-out infinite" }}
+          />
+          {transcript.text}
+        </div>
+      )}
+    </>
+  );
+}
+
+/**
+ * The live status readout, on its own subscription.
+ *
+ * `useSessionSelector` rather than a field off a whole-page `useSession()`: the
+ * header is the only thing here that cares about the session state, and reading
+ * it one level up dragged the incident board through every snapshot change.
+ */
+function StatusReadout() {
+  const state = useSessionSelector((s) => s.state);
+  return (
+    <>
+      <span
+        className="w-2.5 h-2.5 rounded-full inline-block"
+        style={{
+          background: STATE_COLORS[state],
+          animation:
+            state === "listening"
+              ? "dc-pulse 1.5s ease-in-out infinite"
+              : state === "thinking"
+                ? "dc-pulse 0.8s ease-in-out infinite"
+                : "none",
+        }}
+        title={state}
+      />
+      <span className="text-[11px] font-normal normal-case" style={{ color: "#64748b" }}>
+        {state === "listening"
+          ? "LISTENING"
+          : state === "thinking"
+            ? "PROCESSING"
+            : state === "speaking"
+              ? "TRANSMITTING"
+              : state.toUpperCase()}
+      </span>
+    </>
+  );
+}
+
+/**
+ * The fatal-error banner.
+ *
+ * `role="alert"` is the part that is easy to leave out and is load-bearing: per
+ * the `fatalError` latch in the session core this banner is the only remaining
+ * signal — the status eyebrow beside it goes back to reading like a live
+ * session — and a screen reader is never told an unannounced one appeared. It
+ * is what `ConsoleShell` carries, which this template's full-bleed two-pane
+ * board cannot use as its frame.
+ */
+function ErrorBanner() {
+  const error = useSessionSelector((s) => s.error);
+  if (!error) return null;
+  return (
+    <div
+      role="alert"
+      className="px-4 py-2 text-xs"
+      style={{ background: "#450a0a", color: "#fca5a5", borderTop: "1px solid #991b1b" }}
+    >
+      ERROR: {error.message} ({error.code})
+    </div>
+  );
+}
+
+/** The shift controls. The one place a whole-session read is what is wanted:
+ *  it needs `started`, `running` and three methods, and it is three buttons. */
+function ShiftControls({ logged }: { logged: number }) {
   const session = useSession();
-  // `speaking` and `text` in place of a `userTranscript !== null` check: `null`
-  // is silence and `""` is speech detected with no words back yet, and reading
-  // them as one falsy value hides the indicator at the start of every turn.
-  const { speaking, text: userTranscript } = useUserTranscript();
+  return (
+    <div
+      className="flex items-center gap-2.5 px-4 py-3"
+      style={{ background: "#111827", borderTop: "1px solid #1e293b" }}
+    >
+      {!session.started ? (
+        <button
+          type="button"
+          className="px-4 py-2 border-none rounded-md font-mono text-xs font-semibold uppercase tracking-wider cursor-pointer text-white"
+          style={{ background: "#2563eb" }}
+          onClick={() => session.start()}
+        >
+          Start Dispatch
+        </button>
+      ) : (
+        <>
+          <button
+            type="button"
+            className="px-4 py-2 border-none rounded-md font-mono text-xs font-semibold uppercase tracking-wider cursor-pointer"
+            style={{
+              background: session.running ? "#334155" : "#2563eb",
+              color: session.running ? "#e2e8f0" : "white",
+            }}
+            onClick={() => session.toggle()}
+          >
+            {session.running ? "Pause" : "Resume"}
+          </button>
+          {/* end() hangs up and flips `started` back, so the UI
+              returns to "Start Dispatch" and the next start is a
+              brand-new shift (fresh incident board, greeting
+              included). reset() would keep the call live — the
+              buttons never toggle back. */}
+          <button
+            type="button"
+            className="px-4 py-2 border-none rounded-md font-mono text-xs font-semibold uppercase tracking-wider cursor-pointer text-white"
+            style={{ background: "#dc2626" }}
+            onClick={() => session.end()}
+          >
+            End Shift
+          </button>
+        </>
+      )}
+      <div className="flex-1" />
+      <span className="text-[10px]" style={{ color: "#475569" }}>
+        {logged} incident{logged !== 1 ? "s" : ""} logged
+      </span>
+    </div>
+  );
+}
+
+function App() {
   // The agent's own board, projected by `syncState`. This replaced a
   // useState mirror that merged incident deltas out of tool events — the
   // projection is already the complete list, so there is nothing to merge.
+  //
+  // It is the ONLY subscription at this level: the session reads that used to
+  // sit beside it moved into the four components above, so a partial transcript
+  // no longer re-renders the incident cards.
   const dash = useAgentState(dashboardProjection);
 
   const incidentList = [...dash.incidents].reverse();
@@ -179,28 +407,7 @@ function App() {
           >
             <span style={{ color: "#3b82f6" }}>&#9670;</span>
             Dispatch Command Center
-            <span
-              className="w-2.5 h-2.5 rounded-full inline-block"
-              style={{
-                background: STATE_COLORS[session.state],
-                animation:
-                  session.state === "listening"
-                    ? "dc-pulse 1.5s ease-in-out infinite"
-                    : session.state === "thinking"
-                      ? "dc-pulse 0.8s ease-in-out infinite"
-                      : "none",
-              }}
-              title={session.state}
-            />
-            <span className="text-[11px] font-normal normal-case" style={{ color: "#64748b" }}>
-              {session.state === "listening"
-                ? "LISTENING"
-                : session.state === "thinking"
-                  ? "PROCESSING"
-                  : session.state === "speaking"
-                    ? "TRANSMITTING"
-                    : session.state.toUpperCase()}
-            </span>
+            <StatusReadout />
           </div>
           <div className="flex gap-2 items-center">
             <span className="text-[10px] tracking-wider" style={{ color: "#64748b" }}>
@@ -229,106 +436,9 @@ function App() {
             className="flex flex-col overflow-hidden"
             style={{ borderRight: "1px solid #1e293b" }}
           >
-            <AutoScroll
-              scrollClassName="dc-messages overflow-y-auto"
-              contentClassName="p-4 flex flex-col gap-2"
-            >
-              {session.messages.length === 0 && (
-                <div className="text-center p-10 text-[13px]" style={{ color: "#475569" }}>
-                  Dispatch Command Center standing by. Click START to begin operations.
-                </div>
-              )}
-              {session.messages.map((m: ChatMessage, i: number) => (
-                <div
-                  key={i}
-                  className="rounded-lg text-[13px] max-w-[85%] px-3.5 py-2.5"
-                  style={{
-                    lineHeight: 1.6,
-                    alignSelf: m.role === "assistant" ? "flex-start" : "flex-end",
-                    background: m.role === "assistant" ? "#1e293b" : "#172554",
-                    animation: "dc-slide-in 0.2s ease-out",
-                    borderLeft: m.role === "assistant" ? "3px solid #3b82f6" : "none",
-                    borderRight: m.role !== "assistant" ? "3px solid #22d3ee" : "none",
-                  }}
-                >
-                  <div
-                    className="text-[10px] uppercase tracking-wider mb-1"
-                    style={{ color: "#64748b" }}
-                  >
-                    {m.role === "assistant" ? "DISPATCH" : "OPERATOR"}
-                  </div>
-                  {m.content}
-                </div>
-              ))}
-            </AutoScroll>
-
-            {speaking && (
-              <div
-                className="flex items-center px-4 py-2 text-xs italic min-h-8"
-                style={{ background: "#111827", borderTop: "1px solid #1e293b", color: "#64748b" }}
-              >
-                <span
-                  className="w-2.5 h-2.5 rounded-full inline-block mr-2"
-                  style={{ background: "#22c55e", animation: "dc-pulse 1.5s ease-in-out infinite" }}
-                />
-                {userTranscript}
-              </div>
-            )}
-            {session.error && (
-              <div
-                className="px-4 py-2 text-xs"
-                style={{ background: "#450a0a", color: "#fca5a5", borderTop: "1px solid #991b1b" }}
-              >
-                ERROR: {session.error.message} ({session.error.code})
-              </div>
-            )}
-
-            <div
-              className="flex items-center gap-2.5 px-4 py-3"
-              style={{ background: "#111827", borderTop: "1px solid #1e293b" }}
-            >
-              {!session.started ? (
-                <button
-                  type="button"
-                  className="px-4 py-2 border-none rounded-md font-mono text-xs font-semibold uppercase tracking-wider cursor-pointer text-white"
-                  style={{ background: "#2563eb" }}
-                  onClick={() => session.start()}
-                >
-                  Start Dispatch
-                </button>
-              ) : (
-                <>
-                  <button
-                    type="button"
-                    className="px-4 py-2 border-none rounded-md font-mono text-xs font-semibold uppercase tracking-wider cursor-pointer"
-                    style={{
-                      background: session.running ? "#334155" : "#2563eb",
-                      color: session.running ? "#e2e8f0" : "white",
-                    }}
-                    onClick={() => session.toggle()}
-                  >
-                    {session.running ? "Pause" : "Resume"}
-                  </button>
-                  {/* end() hangs up and flips `started` back, so the UI
-                      returns to "Start Dispatch" and the next start is a
-                      brand-new shift (fresh incident board, greeting
-                      included). reset() would keep the call live — the
-                      buttons never toggle back. */}
-                  <button
-                    type="button"
-                    className="px-4 py-2 border-none rounded-md font-mono text-xs font-semibold uppercase tracking-wider cursor-pointer text-white"
-                    style={{ background: "#dc2626" }}
-                    onClick={() => session.end()}
-                  >
-                    End Shift
-                  </button>
-                </>
-              )}
-              <div className="flex-1" />
-              <span className="text-[10px]" style={{ color: "#475569" }}>
-                {incidentList.length} incident{incidentList.length !== 1 ? "s" : ""} logged
-              </span>
-            </div>
+            <Conversation />
+            <ErrorBanner />
+            <ShiftControls logged={incidentList.length} />
           </div>
 
           {/* Right: sidebar dashboard */}

package/dist/templates/dispatch-center/shared.ts

@@ -1,7 +1,7 @@
 // ─── Types ───────────────────────────────────────────────────────────────────
 
 import type { DeepReadonly, ToolFailure } from "@alexkroman1/aai";
-import { pushCapped, sessionSlot } from "@alexkroman1/aai";
+import { dialog, pushCapped, sessionSlot } from "@alexkroman1/aai";
 
 export const SEVERITIES = ["critical", "urgent", "moderate", "minor"] as const;
 export type Severity = (typeof SEVERITIES)[number];
@@ -218,6 +218,104 @@ export const dispatchSlot = sessionSlot("dispatch", createDefaultState, {
 /** The projection BOTH ends use: `syncState` on the agent, `useAgentState` in the client. */
 export const dashboardProjection = dispatchSlot.projection(dashboardView);
 
+// ─── The call in hand ────────────────────────────────────────────────────────
+
+/**
+ * Where the dispatcher is on the call in hand, as a plain state map.
+ *
+ * Declared as a {@link DialogSpec} — `{ initial, states }`, each state carrying
+ * its own `instruction` and `on` map — rather than an XState machine. This
+ * dialog used exactly the four things a spec can say, and the `setup({ types:
+ * {} as { events: … } })` block it used to carry restated the four event names
+ * already written in the `on` maps below. The instruction is a TYPED field now
+ * instead of an untyped `meta` bag, which matters because a misspelling there
+ * produced a refusal with no recovery text and no error anywhere.
+ *
+ * The system prompt used to carry this as prose — "incident_triage: After
+ * creating, assess severity", "Critical incidents get immediate dispatch",
+ * "Never leave a critical incident without at least one resource dispatched" —
+ * which is advice to a model rather than a property of the agent. Two things
+ * change by declaring it.
+ *
+ * **The gate is real.** Six mutating tools take an incident id and did their own
+ * "does this exist" check through {@link findIncident}, whose answer on an empty
+ * board is `Incident INC-0001 not found` — a data answer to a positional
+ * question, and the wrong sentence for a dispatcher who has logged nothing yet.
+ * `when: "working"` is that check now, and the SDK's refusal names where the
+ * shift actually is and quotes the state's instruction.
+ *
+ * **The instruction rides every result.** A flow tool answers with the position
+ * it landed in, so `incident_create`'s result now ends with "confirm the
+ * severity and type with incident_triage" and `incident_triage`'s with "assign
+ * units" — the tool-by-tool sequencing the prompt was spending paragraphs on,
+ * arriving in the last thing the model reads before it speaks.
+ *
+ * **What this position is NOT is per-incident.** A flow is bound to a session
+ * and holds one position, and this board holds many incidents at once — so
+ * `working.monitoring` means "the incident this dispatcher last touched has
+ * units on it", not "every incident does". Per-incident status stays where it
+ * belongs, on {@link Incident.status}, and the tools stay addressed by id. That
+ * is also why `working` is a PARENT state: what every gated tool actually needs
+ * is "something has been logged on this shift", and the three children exist to
+ * carry the instruction for the step in front of the dispatcher rather than to
+ * gate anything.
+ *
+ * `LOGGED` is accepted from every state because a new 911 call is always legal —
+ * the one transition that is not a progression.
+ *
+ * `as const` is what keeps the `on` keys literal, so `DialogEvent` synthesizes
+ * the event union from them and a misspelled `send` is a compile error.
+ */
+const callSpec = {
+  initial: "standby",
+  states: {
+    standby: {
+      instruction:
+        "Nothing is logged on this shift. Take the call — location first, then the " +
+        "nature of the emergency, then the caller's name and callback — and log it " +
+        "with incident_create.",
+      on: { LOGGED: "working" },
+    },
+    working: {
+      initial: "triaging",
+      // Declared on the PARENT so all three children inherit it, which is what
+      // makes a new call legal mid-incident without repeating the transition
+      // three times. The children re-target each other below.
+      on: { LOGGED: ".triaging" },
+      states: {
+        triaging: {
+          instruction:
+            "Logged, not yet triaged. Confirm or override the severity and type with " +
+            "incident_triage. For a critical call, dispatch first and triage alongside it.",
+          on: { TRIAGED: "dispatching", DISPATCHED: "monitoring", ESCALATED: "dispatching" },
+        },
+        dispatching: {
+          instruction:
+            "Triaged, nothing rolling. Assign units with resources_dispatch — never " +
+            "leave a critical incident without at least one.",
+          on: { DISPATCHED: "monitoring", TRIAGED: "dispatching", ESCALATED: "dispatching" },
+        },
+        monitoring: {
+          instruction:
+            "Units are assigned. Work it — status updates as they radio in, notes as " +
+            "the picture changes, escalate if it outgrows the response, and close it " +
+            "with incident_update_status.",
+          on: { TRIAGED: "dispatching", DISPATCHED: "monitoring", ESCALATED: "dispatching" },
+        },
+      },
+    },
+  },
+} as const;
+
+/**
+ * The flow. Its own slot key beside {@link dispatchSlot}: the flow holds the
+ * POSITION and the board holds the incidents, because the position is one fact
+ * about the conversation and the board is many facts about the world. One tool
+ * call moves both — every converted tool opens `dispatchSlot.update` inside its
+ * `execute` and lets the flow's own `send` follow it.
+ */
+export const callFlow = dialog("call", callSpec);
+
 /**
  * The board as a READ hands it out: deep-frozen, and typed to say so.
  *

package/dist/templates/dispatch-center/system-prompt.md

@@ -2,11 +2,13 @@ You are the AI-powered Emergency Dispatch Command Center. You coordinate emergen
 
 Your role combines call-taker, dispatcher, and incident commander. You speak like an experienced dispatcher: calm, precise, and authoritative. Never panic. Use brevity codes and dispatch terminology naturally.
 
+WHERE THE CALL IS: every incident and resource tool answers with the position the call is in and what that position expects next — read it. Those tools refuse outright until something has been logged, and the refusal tells you what to do first. Nothing here has to be remembered between turns.
+
 Your tools:
 
 INCIDENT MANAGEMENT:
 - incident_create: Log a new incident. Ask for location first, then nature of emergency, then caller info. Speed matters for critical calls.
-- incident_triage: After creating, assess severity. The system recommends severity, type, and protocols. Review and confirm or override.
+- incident_triage: Assess severity. The system recommends severity, type, and protocols. Review and confirm or override.
 - incident_update_status: Move incidents through the workflow (en_route, on_scene, resolved, escalated).
 - incident_get: Get details on a specific incident.
 - incident_escalate: Escalate when an incident exceeds current capacity or severity increases.

package/dist/templates/dispatch-center/tools/incident_add_note.ts

@@ -1,25 +1,28 @@
 import { isToolFailure } from "@alexkroman1/aai";
 import { z } from "zod";
-import { dispatchSlot, findIncident, logEvent } from "../shared.ts";
+import { callFlow, dispatchSlot, findIncident, logEvent } from "../shared.ts";
 
-export default dispatchSlot.updateTool({
+/** Gated on `working` — there is nothing to annotate before anything is logged. */
+export default callFlow.tool({
   description: "Add a situational update note to an incident's timeline.",
+  when: "working",
   inputSchema: z.object({
     incidentId: z.string().max(20).describe("The incident ID"),
     note: z.string().max(1000).describe("The note to add"),
     source: z.string().max(100).describe("Who reported this — unit callsign or caller").optional(),
   }),
-  execute(args, state) {
-    const inc = findIncident(state, args.incidentId);
-    if (isToolFailure(inc)) return inc;
+  execute: (args, ctx) =>
+    dispatchSlot.update(ctx, (state) => {
+      const inc = findIncident(state, args.incidentId);
+      if (isToolFailure(inc)) return inc;
 
-    const entry = args.source ? `[${args.source}] ${args.note}` : args.note;
-    logEvent(inc, entry);
+      const entry = args.source ? `[${args.source}] ${args.note}` : args.note;
+      logEvent(inc, entry);
 
-    return {
-      incidentId: args.incidentId,
-      noteAdded: entry,
-      timelineEntries: inc.timeline.length,
-    };
-  },
+      return {
+        incidentId: args.incidentId,
+        noteAdded: entry,
+        timelineEntries: inc.timeline.length,
+      };
+    }),
 });

package/dist/templates/dispatch-center/tools/incident_create.ts

@@ -1,6 +1,7 @@
 import { z } from "zod";
 import {
   calculateTriageScore,
+  callFlow,
   createIncident,
   dispatchSlot,
   getApplicableProtocols,
@@ -10,6 +11,18 @@ import {
   resourceBrief,
 } from "../shared.ts";
 
+/**
+ * **Not a `callFlow.tool`, deliberately.** A new 911 call is legal in every
+ * state, so a `when` listing all of them would be a gate that gates nothing —
+ * the same call `plan-and-execute`'s `start_plan` makes. It sends `LOGGED`
+ * itself, which is what `dialog.send` is public for, and reports the position it
+ * landed in so the model reads "confirm the severity and type" as part of this
+ * result rather than having to remember it from the prompt.
+ *
+ * The `send` sits INSIDE the board's mutation window, which is safe because it
+ * is a different slot: the re-entrancy guard is per slot, and neither window
+ * spans an await, so the whole call commits atomically.
+ */
 export default dispatchSlot.updateTool({
   description: "Create a new incident from an incoming emergency call.",
   inputSchema: z.object({
@@ -29,7 +42,7 @@ export default dispatchSlot.updateTool({
       .describe("Known hazards: fire, chemical, electrical, structural, weapons")
       .optional(),
   }),
-  execute(args, state) {
+  execute(args, state, ctx) {
     const recSeverity = recommendSeverity(args.description);
     const recType = recommendType(args.description);
     const triageScore = calculateTriageScore(
@@ -62,6 +75,11 @@ export default dispatchSlot.updateTool({
 
     return {
       incidentId: id,
+      // Spread the position rather than renaming its fields: this tool is
+      // ungated, so the `{ state, instruction }` a gated tool's result carries
+      // has to come from here — and under two different key sets the model
+      // reads its own position two different ways within one agent.
+      ...callFlow.send(ctx, { type: "LOGGED" }),
       recommendedSeverity: recSeverity,
       recommendedType: recType,
       triageScore,