@alexkroman1/aai-cli 6.11.0 → 8.0.0

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,

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

@@ -3,14 +3,22 @@ import { z } from "zod";
 import {
   assertNotResolved,
   calculateTriageScore,
+  callFlow,
   dispatchSlot,
   findIncident,
   logEvent,
   recommendResources,
 } from "../shared.ts";
 
-export default dispatchSlot.updateTool({
+/**
+ * Gated on `working`, and `ESCALATED` puts the call back in `dispatching`: an
+ * incident that outgrew its response needs more units, which is exactly that
+ * state's instruction.
+ */
+export default callFlow.tool({
   description: "Escalate an incident when it exceeds current capacity or severity increases.",
+  when: "working",
+  send: { type: "ESCALATED" },
   inputSchema: z.object({
     incidentId: z.string().max(20).describe("The incident ID"),
     reason: z.string().max(1000).describe("Reason for escalation"),
@@ -20,67 +28,68 @@ export default dispatchSlot.updateTool({
       .optional(),
     newSeverity: z.enum(["critical", "urgent"]).describe("Escalated severity level").optional(),
   }),
-  execute(args, state) {
-    const inc = findIncident(state, args.incidentId);
-    if (isToolFailure(inc)) return inc;
-    const blocked = assertNotResolved(inc, "escalate");
-    if (blocked) return blocked;
+  execute: (args, ctx) =>
+    dispatchSlot.update(ctx, (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"],
-        },
-      );
-    }
+      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,
-    );
+      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),
-    );
+      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.`,
+      };
+    }),
 });

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

@@ -3,6 +3,7 @@ import { z } from "zod";
 import {
   assertNotResolved,
   calculateTriageScore,
+  callFlow,
   dispatchSlot,
   findIncident,
   getApplicableProtocols,
@@ -12,9 +13,21 @@ import {
   SEVERITIES,
 } from "../shared.ts";
 
-export default dispatchSlot.updateTool({
+/**
+ * Gated on `working`: there is nothing to triage until something has been
+ * logged, and the flow's refusal says so in the dispatcher's own terms where
+ * `findIncident` would have answered `Incident INC-0001 not found` — a data
+ * answer to a positional question.
+ *
+ * `TRIAGED` moves the call to `dispatching`, whose instruction is "assign
+ * units", so the sequencing the system prompt used to spell out tool by tool
+ * arrives in this tool's own result.
+ */
+export default callFlow.tool({
   description:
     "Triage an incident — confirm or override severity, type, hazards, and casualty count.",
+  when: "working",
+  send: { type: "TRIAGED" },
   inputSchema: z.object({
     incidentId: z.string().max(20).describe("The incident ID"),
     severity: z.enum(SEVERITIES).describe("Confirmed severity after triage").optional(),
@@ -27,50 +40,51 @@ export default dispatchSlot.updateTool({
     casualtyUpdate: z.number().int().nonnegative().describe("Updated casualty count").optional(),
     notes: z.string().max(1000).describe("Triage notes").optional(),
   }),
-  execute(args, state) {
-    const inc = findIncident(state, args.incidentId);
-    if (isToolFailure(inc)) return inc;
-    const blocked = assertNotResolved(inc, "triage");
-    if (blocked) return blocked;
+  execute: (args, ctx) =>
+    dispatchSlot.update(ctx, (state) => {
+      const inc = findIncident(state, args.incidentId);
+      if (isToolFailure(inc)) return inc;
+      const blocked = assertNotResolved(inc, "triage");
+      if (blocked) return blocked;
 
-    if (args.severity) inc.severity = args.severity;
-    if (args.type) inc.type = args.type;
-    for (const hazard of args.additionalHazards ?? []) {
-      if (!inc.hazards.includes(hazard)) inc.hazards.push(hazard);
-    }
-    if (args.casualtyUpdate !== undefined) {
-      inc.casualties.estimated = args.casualtyUpdate;
-    }
-    if (args.notes) logEvent(inc, `Triage note: ${args.notes}`);
+      if (args.severity) inc.severity = args.severity;
+      if (args.type) inc.type = args.type;
+      for (const hazard of args.additionalHazards ?? []) {
+        if (!inc.hazards.includes(hazard)) inc.hazards.push(hazard);
+      }
+      if (args.casualtyUpdate !== undefined) {
+        inc.casualties.estimated = args.casualtyUpdate;
+      }
+      if (args.notes) logEvent(inc, `Triage note: ${args.notes}`);
 
-    inc.triageScore = calculateTriageScore(
-      inc.severity,
-      inc.type,
-      inc.casualties.estimated,
-      inc.hazards.length,
-    );
-    inc.status = "triaged";
-    logEvent(inc, `Triaged: ${inc.severity} ${inc.type}, score ${inc.triageScore}`);
+      inc.triageScore = calculateTriageScore(
+        inc.severity,
+        inc.type,
+        inc.casualties.estimated,
+        inc.hazards.length,
+      );
+      inc.status = "triaged";
+      logEvent(inc, `Triaged: ${inc.severity} ${inc.type}, score ${inc.triageScore}`);
 
-    const protocols = getApplicableProtocols(inc.type, inc.severity);
-    const recommended = recommendResources(inc.type, inc.severity, state);
+      const protocols = getApplicableProtocols(inc.type, inc.severity);
+      const recommended = recommendResources(inc.type, inc.severity, state);
 
-    return {
-      incidentId: args.incidentId,
-      severity: inc.severity,
-      type: inc.type,
-      triageScore: inc.triageScore,
-      hazards: inc.hazards,
-      estimatedCasualties: inc.casualties.estimated,
-      protocols: protocols.map((p) => ({
-        name: p.name,
-        steps: p.steps,
-        requiredResources: p.requiredResources,
-      })),
-      recommendedResources: recommended.map((r) => ({
-        callsign: r.callsign,
-        type: r.type,
-      })),
-    };
-  },
+      return {
+        incidentId: args.incidentId,
+        severity: inc.severity,
+        type: inc.type,
+        triageScore: inc.triageScore,
+        hazards: inc.hazards,
+        estimatedCasualties: inc.casualties.estimated,
+        protocols: protocols.map((p) => ({
+          name: p.name,
+          steps: p.steps,
+          requiredResources: p.requiredResources,
+        })),
+        recommendedResources: recommended.map((r) => ({
+          callsign: r.callsign,
+          type: r.type,
+        })),
+      };
+    }),
 });

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

@@ -1,9 +1,17 @@
 import { isToolFailure } from "@alexkroman1/aai";
 import { z } from "zod";
-import { assertNotResolved, dispatchSlot, findIncident, logEvent } from "../shared.ts";
+import { assertNotResolved, callFlow, dispatchSlot, findIncident, logEvent } from "../shared.ts";
 
-export default dispatchSlot.updateTool({
+/**
+ * Gated on `working`; sends nothing. A status update moves the INCIDENT, not
+ * the call — the dispatcher is still in `monitoring` afterwards, and closing
+ * one incident says nothing about the others still on the board. Omitting both
+ * `send` and `sendFrom` is how a flow tool reads without advancing, and the
+ * result still carries the position it read.
+ */
+export default callFlow.tool({
   description: "Update an incident's status (en_route, on_scene, resolved, escalated).",
+  when: "working",
   inputSchema: z.object({
     incidentId: z.string().max(20).describe("The incident ID"),
     status: z.enum(["en_route", "on_scene", "resolved", "escalated"]).describe("New status"),
@@ -16,51 +24,52 @@ export default dispatchSlot.updateTool({
       .describe("Updated casualty numbers")
       .optional(),
   }),
-  execute(args, state) {
-    const inc = findIncident(state, args.incidentId);
-    if (isToolFailure(inc)) return inc;
-    const blocked = assertNotResolved(inc, `set status to ${args.status}`);
-    if (blocked) return blocked;
+  execute: (args, ctx) =>
+    dispatchSlot.update(ctx, (state) => {
+      const inc = findIncident(state, args.incidentId);
+      if (isToolFailure(inc)) return inc;
+      const blocked = assertNotResolved(inc, `set status to ${args.status}`);
+      if (blocked) return blocked;
 
-    inc.status = args.status;
-    logEvent(inc, `Status → ${args.status}${args.notes ? `: ${args.notes}` : ""}`);
+      inc.status = args.status;
+      logEvent(inc, `Status → ${args.status}${args.notes ? `: ${args.notes}` : ""}`);
 
-    if (args.casualtyUpdate) {
-      if (args.casualtyUpdate.confirmed !== undefined) {
-        inc.casualties.confirmed = args.casualtyUpdate.confirmed;
+      if (args.casualtyUpdate) {
+        if (args.casualtyUpdate.confirmed !== undefined) {
+          inc.casualties.confirmed = args.casualtyUpdate.confirmed;
+        }
+        if (args.casualtyUpdate.treated !== undefined) {
+          inc.casualties.treated = args.casualtyUpdate.treated;
+        }
       }
-      if (args.casualtyUpdate.treated !== undefined) {
-        inc.casualties.treated = args.casualtyUpdate.treated;
-      }
-    }
 
-    // Only touch resources still assigned to THIS incident — a unit that
-    // radioed available and was re-dispatched elsewhere belongs to its
-    // new incident now.
-    const ownResources = state.resources.filter((r) => r.assignedIncident === inc.id);
+      // Only touch resources still assigned to THIS incident — a unit that
+      // radioed available and was re-dispatched elsewhere belongs to its
+      // new incident now.
+      const ownResources = state.resources.filter((r) => r.assignedIncident === inc.id);
 
-    if (args.status === "resolved") {
-      for (const r of ownResources) {
-        r.status = "returning";
-        r.assignedIncident = null;
-        r.eta = null;
+      if (args.status === "resolved") {
+        for (const r of ownResources) {
+          r.status = "returning";
+          r.assignedIncident = null;
+          r.eta = null;
+        }
+        inc.assignedResources = [];
+        logEvent(inc, "All resources released — incident closed");
       }
-      inc.assignedResources = [];
-      logEvent(inc, "All resources released — incident closed");
-    }
 
-    if (args.status === "en_route" || args.status === "on_scene") {
-      for (const r of ownResources) {
-        r.status = args.status;
-        if (args.status === "on_scene") r.eta = null;
+      if (args.status === "en_route" || args.status === "on_scene") {
+        for (const r of ownResources) {
+          r.status = args.status;
+          if (args.status === "on_scene") r.eta = null;
+        }
       }
-    }
 
-    return {
-      incidentId: args.incidentId,
-      newStatus: args.status,
-      timeline: inc.timeline.slice(-5).map((t) => t.event),
-      casualties: inc.casualties,
-    };
-  },
+      return {
+        incidentId: args.incidentId,
+        newStatus: args.status,
+        timeline: inc.timeline.slice(-5).map((t) => t.event),
+        casualties: inc.casualties,
+      };
+    }),
 });

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

@@ -1,6 +1,6 @@
 import { z } from "zod";
 import type { Incident, IncidentType, Severity } from "../shared.ts";
-import { calculateTriageScore, createIncident, dispatchSlot } from "../shared.ts";
+import { calculateTriageScore, callFlow, createIncident, dispatchSlot } from "../shared.ts";
 
 type ScenarioIncident = Pick<Incident, "location" | "description" | "type" | "severity">;
 type ScenarioDef = { narrative: string; incidents: ScenarioIncident[] };
@@ -116,12 +116,15 @@ const scenarios = {
 type ScenarioName = keyof typeof scenarios;
 const SCENARIO_NAMES = Object.keys(scenarios) as [ScenarioName, ...ScenarioName[]];
 
+/** Logs incidents like a real call does, so it sends `LOGGED` for the same
+ *  reason `incident_create` does — and is ungated for the same reason too: a
+ *  drill may be started at any point in a shift. */
 export default dispatchSlot.updateTool({
   description: "Run a training scenario that creates simulated incidents for dispatch practice.",
   inputSchema: z.object({
     scenario: z.enum(SCENARIO_NAMES).describe("Scenario type to simulate"),
   }),
-  execute(args, state) {
+  execute(args, state, ctx) {
     const s = scenarios[args.scenario];
 
     const created: string[] = [];
@@ -140,6 +143,9 @@ export default dispatchSlot.updateTool({
       scenario: args.scenario,
       narrative: s.narrative,
       incidentsCreated: created,
+      // As `incident_create`: the position spread verbatim, so an ungated tool
+      // reports it under the same keys a gated one does.
+      ...callFlow.send(ctx, { type: "LOGGED" }),
       message: `SCENARIO ACTIVE: ${s.narrative}. ${created.length} incidents created. Awaiting dispatch orders.`,
     };
   },