@alexkroman1/aai-cli 5.13.2 → 5.14.0

package/dist/scaffold/package.json

@@ -12,15 +12,15 @@
     "publish:agent": "aai publish"
   },
   "dependencies": {
-    "@alexkroman1/aai": "^5.13.2",
-    "@alexkroman1/aai-ui": "^5.13.2",
+    "@alexkroman1/aai": "^5.14.0",
+    "@alexkroman1/aai-ui": "^5.14.0",
     "react": "^19.2.8",
     "react-dom": "^19.2.8",
     "tailwindcss": "^4.0.0",
     "zod": "^4.4.3"
   },
   "devDependencies": {
-    "@alexkroman1/aai-cli": "^5.13.2",
+    "@alexkroman1/aai-cli": "^5.14.0",
     "@tailwindcss/vite": "^4.3.3",
     "@types/node": "^26.1.1",
     "@types/react": "^19.2.17",

package/dist/scaffold/pnpm-workspace.yaml

@@ -11,3 +11,27 @@ onlyBuiltDependencies:
   - esbuild
 allowBuilds:
   esbuild: true
+
+# Exempt our own packages from pnpm's release-age quarantine, and ONLY ours.
+# `minimumReleaseAge` holds a version back until it has been on the registry
+# for N minutes (pnpm 11 turns it on by default; an org .npmrc or a corporate
+# config can set it far higher). The scaffold pins `^<newest>` — see
+# scripts/sync-scaffold-versions.mjs, which resyncs it on every `changeset
+# version` — and this repo publishes several times a day, so EVERY version
+# satisfying that range is younger than the window and resolution fails
+# outright:
+#
+#   ERR_PNPM_NO_MATURE_MATCHING_VERSION  Version 5.13.2 (released 2 hours ago)
+#   of @alexkroman1/aai-cli does not meet the minimumReleaseAge constraint
+#
+# There is no version to fall back to, so a freshly scaffolded project cannot
+# install at all — `aai init` fails at its own install step. Lowering the pin
+# would not help: the floor has to admit the SDK the templates are written
+# against, and that build is by definition new.
+#
+# Quarantine exists to blunt a compromised-release window, so this stays a
+# per-package exemption rather than `minimumReleaseAge: 0` — every third-party
+# dependency keeps whatever window the user has configured. We are the one
+# publisher whose freshness the user is opting into by running `aai init`.
+minimumReleaseAgeExclude:
+  - "@alexkroman1/*"

package/dist/templates/dispatch-center/agent.test.ts

@@ -1,6 +1,7 @@
 import type { ToolContext } from "@alexkroman1/aai";
+import { createToolContext } from "@alexkroman1/aai/testing";
 import { describe, expect, test } from "vitest";
-import { getState } from "./shared.ts";
+import { dispatchSlot, type StateSlot } from "./shared.ts";
 import { incidentCreate } from "./tools/incident_create.ts";
 import { incidentEscalate } from "./tools/incident_escalate.ts";
 import { incidentTriage } from "./tools/incident_triage.ts";
@@ -8,19 +9,11 @@ import { incidentUpdateStatus } from "./tools/incident_update_status.ts";
 import { resourcesDispatch } from "./tools/resources_dispatch.ts";
 import { resourcesUpdateStatus } from "./tools/resources_update_status.ts";
 
-let sessionCounter = 0;
-
-/** ToolContext stub — the dispatch board lives in ctx.state, one per session. */
-function makeCtx(): { ctx: ToolContext } {
-  const sessionId = `test-session-${++sessionCounter}`;
-  const ctx = {
-    sessionId,
-    send: () => {},
-    env: {},
-    state: {},
-    messages: [],
-  } as unknown as ToolContext;
-  return { ctx };
+/** The dispatch board lives in ctx.state, one per session — and
+ *  `createToolContext` gives each call its own session id, so two contexts are
+ *  two boards by construction. */
+function makeCtx(): { ctx: ToolContext<StateSlot> } {
+  return { ctx: createToolContext<StateSlot>() };
 }
 
 async function createIncidentFor(
@@ -49,7 +42,7 @@ describe("dispatch-center template", () => {
     // Resolving the first incident must not touch Medic-1 anymore.
     await incidentUpdateStatus.execute({ incidentId: inc1, status: "resolved" }, ctx);
 
-    const state = getState(ctx);
+    const state = dispatchSlot.get(ctx);
     const medic1 = state.resources.find((r) => r.callsign === "Medic-1");
     expect(medic1?.status).toBe("dispatched");
     expect(medic1?.assignedIncident).toBe(inc2);
@@ -82,7 +75,7 @@ describe("dispatch-center template", () => {
       incidentCreate.execute({ location: "2 Second St", description: "vehicle crash" }, ctx),
     ])) as { incidentId: string }[];
 
-    const state = getState(ctx);
+    const state = dispatchSlot.get(ctx);
     expect(a?.incidentId).not.toBe(b?.incidentId);
     expect(state.incidentCounter).toBe(2);
     expect(Object.keys(state.incidents)).toHaveLength(2);
@@ -121,7 +114,7 @@ describe("dispatch-center template", () => {
       ctx,
     );
 
-    const state = getState(ctx);
+    const state = dispatchSlot.get(ctx);
     const mutualAid = state.resources.filter((r) => r.id.startsWith("MA-"));
     expect(mutualAid).toHaveLength(4);
     expect(new Set(mutualAid.map((r) => r.id)).size).toBe(4);

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

@@ -1,5 +1,5 @@
 import { agent } from "@alexkroman1/aai";
-import { dashboardView } from "./shared.ts";
+import { dashboardView, dispatchSlot } from "./shared.ts";
 import systemPrompt from "./system-prompt.md?raw";
 import { incidentAddNote } from "./tools/incident_add_note.ts";
 import { incidentCreate } from "./tools/incident_create.ts";
@@ -18,7 +18,7 @@ export default agent({
   name: "Dispatch Command Center",
   // One projection replaces eleven `ctx.send("incidents", ...)` calls, and
   // is the single place that decides caller PII stays server-side.
-  syncState: dashboardView,
+  syncState: dispatchSlot.projection(dashboardView),
   // A dispatcher reads addresses and unit numbers in bursts with pauses inside
   // one message ("unit twelve … respond to"). The default pipeline's
   // `max_turn_silence` already tolerates that; reach for

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

@@ -1,9 +1,8 @@
 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 { AutoScroll, client, useAgentState, useSession } 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,7 +53,7 @@ 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"
@@ -133,15 +132,10 @@ function IncidentCard({ inc }: { inc: IncidentSummary }) {
 
 function App() {
   const session = useSession();
-  const messagesEndRef = useRef<HTMLDivElement>(null);
   // 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");
@@ -222,7 +216,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,8 +247,7 @@ function App() {
                   {m.content}
                 </div>
               ))}
-              <div ref={messagesEndRef} />
-            </div>
+            </AutoScroll>
 
             {session.userTranscript !== null && (
               <div

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 { ToolFailure } from "@alexkroman1/aai";
+import { pushCapped, type SlotStateOf, sessionSlot } from "@alexkroman1/aai";
 
 export const SEVERITIES = ["critical", "urgent", "moderate", "minor"] as const;
 export type Severity = (typeof SEVERITIES)[number];
@@ -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: DispatchState): 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 `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.
 
 /**
  * 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,29 @@ 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 inside `ctx.state`.
  *
- * 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.
+ * Mutating tools go through `dispatchSlot.update`, which serializes them per
+ * session: the LLM loop runs a step's tool calls concurrently, and two
+ * interleaving async mutators would each observe the other's half-applied
+ * changes.
  *
- * `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.
- *
- * 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;
-  });
-}
+  },
+});
+
+export type StateSlot = SlotStateOf<typeof dispatchSlot>;
 
 // ─── Incident helpers ────────────────────────────────────────────────────────
 
@@ -263,17 +237,16 @@ export function createIncident(state: DispatchState, overrides: Partial<Incident
   return incident;
 }
 
-export function findIncident(
-  state: DispatchState,
-  incidentId: string,
-): Incident | { error: string } {
+export function findIncident(state: DispatchState, incidentId: string): Incident | 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;
 }
 
@@ -296,7 +269,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: 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.`,

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

@@ -1,6 +1,6 @@
-import { tool } from "@alexkroman1/aai";
+import { isToolFailure, tool } 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({
   description: "Add a situational update note to an incident's timeline.",
@@ -10,9 +10,9 @@ export const incidentAddNote = tool({
     source: z.string().max(100).describe("Who reported this — unit callsign or caller").optional(),
   }),
   async execute(args, ctx) {
-    return updateState(ctx, (state) => {
+    return dispatchSlot.update(ctx, (state) => {
       const inc = findIncident(state, args.incidentId);
-      if ("error" in inc) return inc;
+      if (isToolFailure(inc)) return inc;
 
       const entry = args.source ? `[${args.source}] ${args.note}` : args.note;
       logEvent(inc, entry);

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

@@ -3,12 +3,12 @@ import { z } from "zod";
 import {
   calculateTriageScore,
   createIncident,
+  dispatchSlot,
   getApplicableProtocols,
   recommendResources,
   recommendSeverity,
   recommendType,
   resourceBrief,
-  updateState,
 } from "../shared.ts";
 
 export const incidentCreate = tool({
@@ -31,7 +31,7 @@ export const incidentCreate = tool({
       .optional(),
   }),
   async execute(args, ctx) {
-    return updateState(ctx, (state) => {
+    return dispatchSlot.update(ctx, (state) => {
       const recSeverity = recommendSeverity(args.description);
       const recType = recommendType(args.description);
       const triageScore = calculateTriageScore(

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

@@ -1,12 +1,12 @@
-import { tool } from "@alexkroman1/aai";
+import { isToolFailure, tool } from "@alexkroman1/aai";
 import { z } from "zod";
 import {
   assertNotResolved,
   calculateTriageScore,
+  dispatchSlot,
   findIncident,
   logEvent,
   recommendResources,
-  updateState,
 } from "../shared.ts";
 
 export const incidentEscalate = tool({
@@ -21,9 +21,9 @@ export const incidentEscalate = tool({
     newSeverity: z.enum(["critical", "urgent"]).describe("Escalated severity level").optional(),
   }),
   async execute(args, ctx) {
-    return updateState(ctx, (state) => {
+    return dispatchSlot.update(ctx, (state) => {
       const inc = findIncident(state, args.incidentId);
-      if ("error" in inc) return inc;
+      if (isToolFailure(inc)) return inc;
       const blocked = assertNotResolved(inc, "escalate");
       if (blocked) return blocked;
 

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

@@ -1,6 +1,11 @@
-import { tool } from "@alexkroman1/aai";
+import { isToolFailure, tool } from "@alexkroman1/aai";
 import { z } from "zod";
-import { findIncident, getApplicableProtocols, getState, incidentAgeMinutes } from "../shared.ts";
+import {
+  dispatchSlot,
+  findIncident,
+  getApplicableProtocols,
+  incidentAgeMinutes,
+} from "../shared.ts";
 
 export const incidentGet = tool({
   description: "Get full details on a specific incident including timeline and assigned resources.",
@@ -8,9 +13,9 @@ export const incidentGet = tool({
     incidentId: z.string().max(20).describe("The incident ID"),
   }),
   async execute(args, ctx) {
-    const state = getState(ctx);
+    const state = dispatchSlot.get(ctx);
     const inc = findIncident(state, args.incidentId);
-    if ("error" in inc) return inc;
+    if (isToolFailure(inc)) return inc;
 
     const assignedResourceDetails = inc.assignedResources
       .map((rId) => {

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

@@ -1,15 +1,15 @@
-import { tool } from "@alexkroman1/aai";
+import { isToolFailure, tool } from "@alexkroman1/aai";
 import { z } from "zod";
 import {
   assertNotResolved,
   calculateTriageScore,
+  dispatchSlot,
   findIncident,
   getApplicableProtocols,
   INCIDENT_TYPES,
   logEvent,
   recommendResources,
   SEVERITIES,
-  updateState,
 } from "../shared.ts";
 
 export const incidentTriage = tool({
@@ -28,9 +28,9 @@ export const incidentTriage = tool({
     notes: z.string().max(1000).describe("Triage notes").optional(),
   }),
   async execute(args, ctx) {
-    return updateState(ctx, (state) => {
+    return dispatchSlot.update(ctx, (state) => {
       const inc = findIncident(state, args.incidentId);
-      if ("error" in inc) return inc;
+      if (isToolFailure(inc)) return inc;
       const blocked = assertNotResolved(inc, "triage");
       if (blocked) return blocked;
 

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

@@ -1,6 +1,6 @@
-import { tool } from "@alexkroman1/aai";
+import { isToolFailure, tool } from "@alexkroman1/aai";
 import { z } from "zod";
-import { assertNotResolved, findIncident, logEvent, updateState } from "../shared.ts";
+import { assertNotResolved, dispatchSlot, findIncident, logEvent } from "../shared.ts";
 
 export const incidentUpdateStatus = tool({
   description: "Update an incident's status (en_route, on_scene, resolved, escalated).",
@@ -17,9 +17,9 @@ export const incidentUpdateStatus = tool({
       .optional(),
   }),
   async execute(args, ctx) {
-    return updateState(ctx, (state) => {
+    return dispatchSlot.update(ctx, (state) => {
       const inc = findIncident(state, args.incidentId);
-      if ("error" in inc) return inc;
+      if (isToolFailure(inc)) return inc;
       const blocked = assertNotResolved(inc, `set status to ${args.status}`);
       if (blocked) return blocked;
 

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

@@ -1,11 +1,11 @@
 import { tool } from "@alexkroman1/aai";
-import { getState, incidentAgeMinutes, resourceBrief, resourceUtilization } from "../shared.ts";
+import { dispatchSlot, incidentAgeMinutes, resourceBrief, resourceUtilization } from "../shared.ts";
 
 export const opsDashboard = tool({
   description:
     "Get the full operational dashboard: alert level, resource utilization, active incidents, and available resources.",
   async execute(_args, ctx) {
-    const state = getState(ctx);
+    const state = dispatchSlot.get(ctx);
 
     const activeIncidents = Object.values(state.incidents)
       .filter((i) => i.status !== "resolved")

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

@@ -1,7 +1,7 @@
 import { tool } from "@alexkroman1/aai";
 import { z } from "zod";
 import type { Incident, IncidentType, Severity } from "../shared.ts";
-import { calculateTriageScore, createIncident, updateState } from "../shared.ts";
+import { calculateTriageScore, createIncident, dispatchSlot } from "../shared.ts";
 
 type ScenarioIncident = Pick<Incident, "location" | "description" | "type" | "severity">;
 type ScenarioDef = { narrative: string; incidents: ScenarioIncident[] };
@@ -123,7 +123,7 @@ export const opsRunScenario = tool({
     scenario: z.enum(SCENARIO_NAMES).describe("Scenario type to simulate"),
   }),
   async execute(args, ctx) {
-    return updateState(ctx, (state) => {
+    return dispatchSlot.update(ctx, (state) => {
       const s = scenarios[args.scenario];
 
       const created: string[] = [];

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

@@ -1,12 +1,12 @@
-import { tool } from "@alexkroman1/aai";
+import { isToolFailure, tool } from "@alexkroman1/aai";
 import { z } from "zod";
 import type { Resource } from "../shared.ts";
 import {
   assertNotResolved,
+  dispatchSlot,
   findIncident,
   logEvent,
   recommendResources,
-  updateState,
 } from "../shared.ts";
 
 export const resourcesDispatch = tool({
@@ -31,9 +31,9 @@ export const resourcesDispatch = tool({
       .optional(),
   }),
   async execute(args, ctx) {
-    return updateState(ctx, (state) => {
+    return dispatchSlot.update(ctx, (state) => {
       const inc = findIncident(state, args.incidentId);
-      if ("error" in inc) return inc;
+      if (isToolFailure(inc)) return inc;
       const blocked = assertNotResolved(inc, "dispatch resources");
       if (blocked) return blocked;
 

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

@@ -1,6 +1,6 @@
 import { tool } from "@alexkroman1/aai";
 import { z } from "zod";
-import { getState, RESOURCE_TYPES } from "../shared.ts";
+import { dispatchSlot, RESOURCE_TYPES } from "../shared.ts";
 
 export const resourcesGetAvailable = tool({
   description: "List available resources, optionally filtered by type.",
@@ -11,7 +11,7 @@ export const resourcesGetAvailable = tool({
       .optional(),
   }),
   async execute(args, ctx) {
-    const state = getState(ctx);
+    const state = dispatchSlot.get(ctx);
     let resources = state.resources;
     if (args.type && args.type !== "all") {
       resources = resources.filter((r) => r.type === args.type);

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

@@ -1,6 +1,6 @@
 import { tool } from "@alexkroman1/aai";
 import { z } from "zod";
-import { logEvent, RESOURCE_STATUSES, updateState } from "../shared.ts";
+import { dispatchSlot, logEvent, RESOURCE_STATUSES } from "../shared.ts";
 
 export const resourcesUpdateStatus = tool({
   description: "Update a resource unit's status when it radios in.",
@@ -10,7 +10,7 @@ export const resourcesUpdateStatus = tool({
     notes: z.string().max(1000).describe("Status notes").optional(),
   }),
   async execute(args, ctx) {
-    return updateState(ctx, (state) => {
+    return dispatchSlot.update(ctx, (state) => {
       const resource = state.resources.find(
         (r) => r.callsign.toLowerCase() === args.callsign.toLowerCase(),
       );