@alexkroman1/aai-cli 5.13.2 → 6.1.0

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

@@ -1,9 +1,14 @@
 import "@alexkroman1/aai-ui/styles.css";
-import type { ChatMessage } from "@alexkroman1/aai-ui";
-import { client, useAgentState, useSession } from "@alexkroman1/aai-ui";
-import { useEffect, useRef } from "react";
+import type { AgentState, ChatMessage } from "@alexkroman1/aai-ui";
+import {
+  AutoScroll,
+  client,
+  useAgentState,
+  useSession,
+  useUserTranscript,
+} from "@alexkroman1/aai-ui";
 import type { DashboardView, DispatchState, IncidentSummary, Severity, Status } from "./shared.ts";
-import { dashboardView } from "./shared.ts";
+import { dashboardView, dispatchSlot } from "./shared.ts";
 
 const CSS = `
 @keyframes dc-pulse {
@@ -54,19 +59,26 @@ const statusColors: Record<string, string> = {
 
 // The board before the first tool call — derived from the projection so a
 // new DashboardView field can't silently miss the pre-first-tool-call render.
-const EMPTY_DASH = dashboardView({});
+const EMPTY_DASH: DashboardView = dispatchSlot.projection(dashboardView)(undefined);
 
-function stateColor(state: string): string {
-  return state === "listening"
-    ? "#22c55e"
-    : state === "thinking"
-      ? "#eab308"
-      : state === "speaking"
-        ? "#3b82f6"
-        : state === "ready"
-          ? "#22c55e"
-          : "#6b7280";
-}
+// The dot's colour per session state, as an EXHAUSTIVE map rather than an
+// if-chain with a grey default.
+//
+// The palette is this template's own — every client here paints the same six
+// states in its own colours, so the SDK has nothing to share but the union. What
+// the SDK does own is `AgentState`, and `satisfies Record<AgentState, string>`
+// is what borrows it: a state added there stops compiling here, where the
+// `state === "…"` chain this replaced answered a new state with a silent grey
+// badge in three separate files and no way to notice.
+const STATE_COLORS = {
+  disconnected: "#6b7280",
+  connecting: "#6b7280",
+  ready: "#22c55e",
+  listening: "#22c55e",
+  thinking: "#eab308",
+  speaking: "#3b82f6",
+  error: "#6b7280",
+} satisfies Record<AgentState, string>;
 
 function Panel({ title, children }: { title: string; children: React.ReactNode }) {
   return (
@@ -133,15 +145,14 @@ function IncidentCard({ inc }: { inc: IncidentSummary }) {
 
 function App() {
   const session = useSession();
-  const messagesEndRef = useRef<HTMLDivElement>(null);
+  // `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();
   // 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.
-  const dash = useAgentState<DashboardView>() ?? EMPTY_DASH;
-
-  useEffect(() => {
-    messagesEndRef.current?.scrollIntoView({ behavior: "smooth" });
-  }, [session.messages]);
+  const dash = useAgentState<DashboardView>(EMPTY_DASH);
 
   const incidentList = [...dash.incidents].reverse();
   const activeIncidents = incidentList.filter((i) => i.status !== "resolved");
@@ -175,7 +186,7 @@ function App() {
             <span
               className="w-2.5 h-2.5 rounded-full inline-block"
               style={{
-                background: stateColor(session.state),
+                background: STATE_COLORS[session.state],
                 animation:
                   session.state === "listening"
                     ? "dc-pulse 1.5s ease-in-out infinite"
@@ -222,7 +233,10 @@ function App() {
             className="flex flex-col overflow-hidden"
             style={{ borderRight: "1px solid #1e293b" }}
           >
-            <div className="dc-messages flex-1 overflow-y-auto p-4 flex flex-col gap-2">
+            <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.
@@ -250,10 +264,9 @@ function App() {
                   {m.content}
                 </div>
               ))}
-              <div ref={messagesEndRef} />
-            </div>
+            </AutoScroll>
 
-            {session.userTranscript !== null && (
+            {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" }}
@@ -262,7 +275,7 @@ function App() {
                   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" }}
                 />
-                {session.userTranscript === "" ? "..." : session.userTranscript}
+                {userTranscript}
               </div>
             )}
             {session.error && (

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

@@ -1,7 +1,7 @@
 // ─── Types ───────────────────────────────────────────────────────────────────
 
-import type { ToolContext } from "@alexkroman1/aai";
-import { createKeyedLock, withLock } from "@alexkroman1/aai";
+import type { DeepReadonly, ToolFailure } from "@alexkroman1/aai";
+import { pushCapped, sessionSlot } from "@alexkroman1/aai";
 
 export const SEVERITIES = ["critical", "urgent", "moderate", "minor"] as const;
 export type Severity = (typeof SEVERITIES)[number];
@@ -101,7 +101,7 @@ export interface IncidentSummary {
   location: string;
 }
 
-export function incidentSummary(inc: Incident): IncidentSummary {
+export function incidentSummary(inc: DeepReadonly<Incident>): IncidentSummary {
   return { id: inc.id, severity: inc.severity, status: inc.status, location: inc.location };
 }
 
@@ -111,22 +111,16 @@ export interface DashboardView {
   incidents: IncidentSummary[];
 }
 
-/** The `syncState` projection — the whole contract with client.tsx. */
-export function dashboardView(state: StateSlot): DashboardView {
-  const dispatch = state.dispatch;
+/** The `syncState` projection — the whole contract with client.tsx. Takes the
+ *  board itself, not the slot: `dispatchSlot.projection` supplies a real one
+ *  even before the first tool call. */
+export function dashboardView(state: FrozenDispatchState): DashboardView {
   return {
-    systemAlertLevel: dispatch?.alertLevel ?? "green",
-    incidents: Object.values(dispatch?.incidents ?? {}).map(incidentSummary),
+    systemAlertLevel: state.alertLevel,
+    incidents: Object.values(state.incidents).map(incidentSummary),
   };
 }
 
-// ─── State helpers ───────────────────────────────────────────────────────────
-// The dispatch board lives in `ctx.state`, the agent's per-session mutable
-// state — sessions must not see each other's incidents, and ctx.state gives
-// that isolation by construction. Nothing here needs to outlive the session.
-
-export type StateSlot = { dispatch?: DispatchState };
-
 // ─── Resource generation ────────────────────────────────────────────────────
 
 const RESOURCE_DEFS: [string, Resource["type"], string, string[]][] = [
@@ -167,15 +161,10 @@ export function createDefaultState(): DispatchState {
   };
 }
 
-/** The session's live dispatch state. Mutations to the returned object
- *  stick — it is the object stored in `ctx.state`. */
-export function getState(ctx: ToolContext): DispatchState {
-  const slot = ctx.state as StateSlot;
-  slot.dispatch ??= createDefaultState();
-  return slot.dispatch;
-}
-
-// ─── Serialized state updates ────────────────────────────────────────────────
+// ─── State helpers ───────────────────────────────────────────────────────────
+// The dispatch board lives in one `sessionSlot`, keyed per session — sessions
+// must not see each other's incidents, and a slot gives that isolation by
+// construction.
 
 /**
  * Growth caps. The whole dispatch state is one object whose summaries feed
@@ -183,8 +172,10 @@ export function getState(ctx: ToolContext): DispatchState {
  * timelines must be pruned or a long session's payloads grow without bound.
  */
 const MAX_RESOLVED_KEPT = 10;
-const MAX_TIMELINE_ENTRIES = 50;
+export const MAX_TIMELINE_ENTRIES = 50;
 
+/** Resolved incidents only — the timeline cap is held on append by
+ *  `logEvent`, so nothing here has to re-trim it. */
 function pruneState(state: DispatchState): void {
   const resolved = Object.values(state.incidents)
     .filter((i) => i.status === "resolved")
@@ -192,46 +183,48 @@ function pruneState(state: DispatchState): void {
   for (const inc of resolved.slice(MAX_RESOLVED_KEPT)) {
     delete state.incidents[inc.id];
   }
-  for (const inc of Object.values(state.incidents)) {
-    if (inc.timeline.length > MAX_TIMELINE_ENTRIES) {
-      inc.timeline = inc.timeline.slice(-MAX_TIMELINE_ENTRIES);
-    }
-  }
 }
 
-const sessionLock = createKeyedLock();
-
 /**
- * Serialized update of the session's dispatch state.
+ * The session's dispatch board, as one typed slot.
  *
- * The LLM loop executes parallel tool calls concurrently. The state lives in
- * `ctx.state` now (one shared object, no snapshot/save round-trip), but a
- * mutator may be async, and two interleaving async mutators can each observe
- * the other's half-applied changes. Holding the session's key makes each
- * update run against the previous one's finished result. It also centralizes
- * the shared bookkeeping every mutating tool needs: pruning and alert-level
- * recalculation.
+ * Every tool here is declared through the slot rather than reaching for it from
+ * inside a `tool()` body, and WHICH HALF is the whole decision: `updateTool`
+ * runs the body inside the mutation window and hands it a draft that is stored
+ * when the body returns, `tool` hands it the deep-frozen stored value. That
+ * makes "does this tool write?" a property of the declaration a reader can see,
+ * and choosing wrong a compile error rather than a `TypeError` on the first
+ * call.
  *
- * `createKeyedLock` rather than a hand-rolled promise chain per session: the
- * SDK's drops each key's entry once its chain drains (so a long-running agent
- * does not accumulate one per session id) and does it by ownership, which is
- * the part a hand-rolled chain gets wrong.
+ * The window is SYNCHRONOUS, which is what makes a read-modify-write atomic
+ * with no lock — the LLM loop runs a step's tool calls concurrently. It does
+ * NOT serialize anything (an earlier version of this comment claimed it did):
+ * there is nothing to serialize, because no other JS turn can interleave with
+ * a synchronous body. `updateTool` is what enforces the rule, refusing a
+ * thenable body by name.
  *
- * There is no post-save callback: pushing the board to the client used to
- * need one, and `syncState` now does it after every tool call.
+ * `after` is the bookkeeping every mutating tool needs and none of them should
+ * have to remember — pruning resolved incidents, and recalculating the alert
+ * level the dashboard reads. Declaring it here rather than at each call site is
+ * the point: a new mutating tool gets both for free.
  */
-export function updateState<R>(
-  ctx: ToolContext,
-  mutator: (state: DispatchState) => R | Promise<R>,
-): Promise<R> {
-  return withLock(sessionLock, ctx.sessionId, async () => {
-    const state = getState(ctx);
-    const result = await mutator(state);
+export const dispatchSlot = sessionSlot("dispatch", createDefaultState, {
+  after: (state) => {
     pruneState(state);
     recalculateAlertLevel(state);
-    return result;
-  });
-}
+  },
+});
+
+/**
+ * The board as a READ hands it out: deep-frozen, and typed to say so.
+ *
+ * The pure helpers below take this rather than {@link DispatchState}, which is
+ * the widening a deep-readonly slot forces and the reason it is worth doing: a
+ * mutable board still satisfies it, so a helper called with an `updateTool`
+ * draft is unaffected, while a helper that WOULD have mutated stops compiling
+ * instead of throwing at its first call in production.
+ */
+export type FrozenDispatchState = DeepReadonly<DispatchState>;
 
 // ─── Incident helpers ────────────────────────────────────────────────────────
 
@@ -263,32 +256,46 @@ export function createIncident(state: DispatchState, overrides: Partial<Incident
   return incident;
 }
 
-export function findIncident(
-  state: DispatchState,
+/**
+ * One incident by id, or the failure the model should read.
+ *
+ * Generic over the incident's own type rather than pinned to {@link Incident},
+ * so ONE lookup serves both halves of the slot: a mutating tool passes its
+ * draft and gets a mutable incident back to change, while `incident_get` passes
+ * what `dispatchSlot.tool` handed it — deep-frozen — and gets a readonly one.
+ * Pinning it would have made the read path the odd one out, and its way out
+ * would have been a cast.
+ */
+export function findIncident<I extends DeepReadonly<Incident>>(
+  state: { readonly incidents: { readonly [id: string]: I } },
   incidentId: string,
-): Incident | { error: string } {
+): I | ToolFailure {
   return state.incidents[incidentId] ?? { error: `Incident ${incidentId} not found` };
 }
 
-/** Append a timeline entry and touch `updatedAt`. */
+/** Append a timeline entry and touch `updatedAt`, holding
+ *  {@link MAX_TIMELINE_ENTRIES}. Capped on APPEND rather than swept later, so
+ *  a single long-running incident cannot outgrow the payload between sweeps. */
 export function logEvent(inc: Incident, event: string): void {
   const time = Date.now();
-  inc.timeline.push({ time, event });
+  pushCapped(inc.timeline, { time, event }, MAX_TIMELINE_ENTRIES);
   inc.updatedAt = time;
 }
 
 /** Minutes since the incident was created, rounded. */
-export function incidentAgeMinutes(inc: Incident): number {
+export function incidentAgeMinutes(inc: DeepReadonly<Incident>): number {
   return Math.round((Date.now() - inc.createdAt) / 60_000);
 }
 
 /** A resource as tool results describe it to the LLM. */
-export function resourceBrief(r: Resource): {
+export function resourceBrief(r: DeepReadonly<Resource>): {
   callsign: string;
   type: Resource["type"];
   capabilities: string[];
 } {
-  return { callsign: r.callsign, type: r.type, capabilities: r.capabilities };
+  // `capabilities` is COPIED: a brief is a fresh object handed to the LLM, and
+  // the source list belongs either to a frozen slot value or to a live draft.
+  return { callsign: r.callsign, type: r.type, capabilities: [...r.capabilities] };
 }
 
 /**
@@ -296,7 +303,7 @@ export function resourceBrief(r: Resource): {
  * resources have been released (and possibly reassigned), so escalating,
  * re-resolving, or dispatching to it would corrupt resource assignments.
  */
-export function assertNotResolved(inc: Incident, action: string): { error: string } | null {
+export function assertNotResolved(inc: DeepReadonly<Incident>, action: string): ToolFailure | null {
   if (inc.status === "resolved") {
     return {
       error: `Incident ${inc.id} is resolved — cannot ${action}. Create a new incident if the situation has reopened.`,
@@ -602,7 +609,7 @@ export function recommendResources(
 /** Fraction of resources not currently available, 0–1. The alert level and
  *  the dashboard's displayed utilization both derive from this, so they can
  *  never disagree about what "utilization" means. */
-export function resourceUtilization(state: DispatchState): number {
+export function resourceUtilization(state: FrozenDispatchState): number {
   const available = state.resources.filter((r) => r.status === "available").length;
   return 1 - available / state.resources.length;
 }

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

@@ -1,27 +1,25 @@
-import { tool } from "@alexkroman1/aai";
+import { isToolFailure } from "@alexkroman1/aai";
 import { z } from "zod";
-import { findIncident, logEvent, updateState } from "../shared.ts";
+import { dispatchSlot, findIncident, logEvent } from "../shared.ts";
 
-export const incidentAddNote = tool({
+export default dispatchSlot.updateTool({
   description: "Add a situational update note to an incident's timeline.",
   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(),
   }),
-  async execute(args, ctx) {
-    return updateState(ctx, (state) => {
-      const inc = findIncident(state, args.incidentId);
-      if ("error" in inc) return inc;
+  execute(args, 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,17 +1,16 @@
-import { tool } from "@alexkroman1/aai";
 import { z } from "zod";
 import {
   calculateTriageScore,
   createIncident,
+  dispatchSlot,
   getApplicableProtocols,
   recommendResources,
   recommendSeverity,
   recommendType,
   resourceBrief,
-  updateState,
 } from "../shared.ts";
 
-export const incidentCreate = tool({
+export default dispatchSlot.updateTool({
   description: "Create a new incident from an incoming emergency call.",
   inputSchema: z.object({
     location: z.string().max(300).describe("Address or location description"),
@@ -30,50 +29,48 @@ export const incidentCreate = tool({
       .describe("Known hazards: fire, chemical, electrical, structural, weapons")
       .optional(),
   }),
-  async execute(args, ctx) {
-    return updateState(ctx, (state) => {
-      const recSeverity = recommendSeverity(args.description);
-      const recType = recommendType(args.description);
-      const triageScore = calculateTriageScore(
-        recSeverity,
-        recType,
-        args.estimatedCasualties ?? 0,
-        args.hazards?.length ?? 0,
-      );
+  execute(args, state) {
+    const recSeverity = recommendSeverity(args.description);
+    const recType = recommendType(args.description);
+    const triageScore = calculateTriageScore(
+      recSeverity,
+      recType,
+      args.estimatedCasualties ?? 0,
+      args.hazards?.length ?? 0,
+    );
 
-      const incident = createIncident(state, {
-        type: recType,
-        severity: recSeverity,
-        location: args.location,
-        description: args.description,
-        callerName: args.callerName ?? "Unknown",
-        callerPhone: args.callerPhone ?? "Unknown",
-        triageScore,
-        timeline: [{ time: Date.now(), event: `Incident created: ${args.description}` }],
-        casualties: {
-          confirmed: 0,
-          estimated: args.estimatedCasualties ?? 0,
-          treated: 0,
-        },
-        hazards: args.hazards ?? [],
-      });
-      const id = incident.id;
+    const incident = createIncident(state, {
+      type: recType,
+      severity: recSeverity,
+      location: args.location,
+      description: args.description,
+      callerName: args.callerName ?? "Unknown",
+      callerPhone: args.callerPhone ?? "Unknown",
+      triageScore,
+      timeline: [{ time: Date.now(), event: `Incident created: ${args.description}` }],
+      casualties: {
+        confirmed: 0,
+        estimated: args.estimatedCasualties ?? 0,
+        treated: 0,
+      },
+      hazards: args.hazards ?? [],
+    });
+    const id = incident.id;
 
-      const protocols = getApplicableProtocols(recType, recSeverity);
-      const recommended = recommendResources(recType, recSeverity, state);
+    const protocols = getApplicableProtocols(recType, recSeverity);
+    const recommended = recommendResources(recType, recSeverity, state);
 
-      return {
-        incidentId: id,
-        recommendedSeverity: recSeverity,
-        recommendedType: recType,
-        triageScore,
-        applicableProtocols: protocols.map((p) => p.name),
-        recommendedResources: recommended.map(resourceBrief),
-        message:
-          recSeverity === "critical"
-            ? `PRIORITY ONE — ${id} created. Immediate dispatch recommended. ${protocols.length} protocol(s) applicable.`
-            : `${id} created. Triage score ${triageScore}. ${recommended.length} resource(s) recommended.`,
-      };
-    });
+    return {
+      incidentId: id,
+      recommendedSeverity: recSeverity,
+      recommendedType: recType,
+      triageScore,
+      applicableProtocols: protocols.map((p) => p.name),
+      recommendedResources: recommended.map(resourceBrief),
+      message:
+        recSeverity === "critical"
+          ? `PRIORITY ONE — ${id} created. Immediate dispatch recommended. ${protocols.length} protocol(s) applicable.`
+          : `${id} created. Triage score ${triageScore}. ${recommended.length} resource(s) recommended.`,
+    };
   },
 });

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

@@ -1,15 +1,15 @@
-import { tool } from "@alexkroman1/aai";
+import { isToolFailure } from "@alexkroman1/aai";
 import { z } from "zod";
 import {
   assertNotResolved,
   calculateTriageScore,
+  dispatchSlot,
   findIncident,
   logEvent,
   recommendResources,
-  updateState,
 } from "../shared.ts";
 
-export const incidentEscalate = tool({
+export default dispatchSlot.updateTool({
   description: "Escalate an incident when it exceeds current capacity or severity increases.",
   inputSchema: z.object({
     incidentId: z.string().max(20).describe("The incident ID"),
@@ -20,69 +20,67 @@ export const incidentEscalate = tool({
       .optional(),
     newSeverity: z.enum(["critical", "urgent"]).describe("Escalated severity level").optional(),
   }),
-  async execute(args, ctx) {
-    return updateState(ctx, (state) => {
-      const inc = findIncident(state, args.incidentId);
-      if ("error" in inc) return inc;
-      const blocked = assertNotResolved(inc, "escalate");
-      if (blocked) return blocked;
+  execute(args, state) {
+    const inc = findIncident(state, args.incidentId);
+    if (isToolFailure(inc)) return inc;
+    const blocked = assertNotResolved(inc, "escalate");
+    if (blocked) return blocked;
 
-      inc.escalationLevel++;
-      if (args.newSeverity) inc.severity = args.newSeverity;
-      inc.status = "escalated";
-      logEvent(inc, `ESCALATED (Level ${inc.escalationLevel}): ${args.reason}`);
+    inc.escalationLevel++;
+    if (args.newSeverity) inc.severity = args.newSeverity;
+    inc.status = "escalated";
+    logEvent(inc, `ESCALATED (Level ${inc.escalationLevel}): ${args.reason}`);
 
-      if (args.requestMutualAid) {
-        logEvent(inc, "Mutual aid requested from neighboring jurisdictions");
-        // Counter-based ids/callsigns: Date.now() collides across rapid
-        // escalations, and duplicate callsigns break dispatch-by-callsign.
-        const medicN = ++state.mutualAidCounter;
-        const engineN = ++state.mutualAidCounter;
-        state.resources.push(
-          {
-            id: `MA-${medicN}`,
-            type: "ambulance",
-            callsign: `Mutual-Aid-Medic-${medicN}`,
-            status: "available",
-            assignedIncident: null,
-            eta: null,
-            capabilities: ["als"],
-          },
-          {
-            id: `MA-${engineN}`,
-            type: "fire_engine",
-            callsign: `Mutual-Aid-Engine-${engineN}`,
-            status: "available",
-            assignedIncident: null,
-            eta: null,
-            capabilities: ["structural"],
-          },
-        );
-      }
-
-      inc.triageScore = calculateTriageScore(
-        inc.severity,
-        inc.type,
-        inc.casualties.estimated,
-        inc.hazards.length,
+    if (args.requestMutualAid) {
+      logEvent(inc, "Mutual aid requested from neighboring jurisdictions");
+      // Counter-based ids/callsigns: Date.now() collides across rapid
+      // escalations, and duplicate callsigns break dispatch-by-callsign.
+      const medicN = ++state.mutualAidCounter;
+      const engineN = ++state.mutualAidCounter;
+      state.resources.push(
+        {
+          id: `MA-${medicN}`,
+          type: "ambulance",
+          callsign: `Mutual-Aid-Medic-${medicN}`,
+          status: "available",
+          assignedIncident: null,
+          eta: null,
+          capabilities: ["als"],
+        },
+        {
+          id: `MA-${engineN}`,
+          type: "fire_engine",
+          callsign: `Mutual-Aid-Engine-${engineN}`,
+          status: "available",
+          assignedIncident: null,
+          eta: null,
+          capabilities: ["structural"],
+        },
       );
+    }
 
-      const additionalResources = recommendResources(inc.type, inc.severity, state).filter(
-        (r) => !inc.assignedResources.includes(r.id),
-      );
+    inc.triageScore = calculateTriageScore(
+      inc.severity,
+      inc.type,
+      inc.casualties.estimated,
+      inc.hazards.length,
+    );
+
+    const additionalResources = recommendResources(inc.type, inc.severity, state).filter(
+      (r) => !inc.assignedResources.includes(r.id),
+    );
 
-      return {
-        incidentId: args.incidentId,
-        escalationLevel: inc.escalationLevel,
-        newSeverity: inc.severity,
-        newTriageScore: inc.triageScore,
-        mutualAidRequested: args.requestMutualAid ?? false,
-        additionalResourcesAvailable: additionalResources.map((r) => ({
-          callsign: r.callsign,
-          type: r.type,
-        })),
-        message: `ESCALATION CONFIRMED — ${args.incidentId} now Level ${inc.escalationLevel}. ${additionalResources.length} additional resource(s) available for dispatch.`,
-      };
-    });
+    return {
+      incidentId: args.incidentId,
+      escalationLevel: inc.escalationLevel,
+      newSeverity: inc.severity,
+      newTriageScore: inc.triageScore,
+      mutualAidRequested: args.requestMutualAid ?? false,
+      additionalResourcesAvailable: additionalResources.map((r) => ({
+        callsign: r.callsign,
+        type: r.type,
+      })),
+      message: `ESCALATION CONFIRMED — ${args.incidentId} now Level ${inc.escalationLevel}. ${additionalResources.length} additional resource(s) available for dispatch.`,
+    };
   },
 });