@aeolus-fleet/core 0.24.0 → 0.25.0

package/README.md

@@ -64,7 +64,7 @@ A session crews an agent ship with `ship.register`: the ship id and secret from
 
 `ship.send` sends a message from the calling ship (a crew token, or the console session as `argo`); it needs the `messages:send` scope. It takes a selector (`{ "kind": "ship", "shipId": "shp_..." }`, `{ "kind": "ship", "name": "scout" }` or `{ "kind": "type", "type": "reviewer" }`), a payload (text of at most 64 KB in UTF-8, never parsed), optionally its content type (any well-formed media type, such as `text/plain` or `application/json; charset=utf-8`, passed on untouched; `text/plain` when left out), the sender's own idempotency key (1 to 256 characters) and, for a reply, `inReplyTo` (a message id of the fleet). A name is resolved to the ship's id when the message is sent; a retired or unknown ship, or a type without an active ship, is refused. It answers `{ "messageId": "msg_..." }` only once the message and its delivery are stored. A repeat of the key with the same request (selector as sent, payload, content type, `inReplyTo`; no content type is the same as `text/plain`) answers with the original id; the same key with another request is refused (`CONFLICT`). When the send commits, Postgres `NOTIFY` announces the delivery on the channel `aeolus_delivery_pending`.
 
-`ship.receive` and `ship.ack` take the crew token only (the console session is refused) and need the `messages:receive` scope. `ship.receive` takes `{ "max": 1 to 10 }`, one when left out, and answers `{ "deliveries": [...] }`: the crew's own unacknowledged deliveries in flight first, then the oldest pending ones for its ship or its type. Each comes with its message and its sender (`deliveryId`, `messageId`, `senderShipId`, `senderName`, `senderType`, `recipient`, `payload`, `contentType`, `inReplyTo`, `sentAt`, `attempts`; the sender's name and type as they are at the receive, so a renamed sender goes by its new name) and stays in flight until acknowledged or the lease ends; the crew's next receive returns it again, counted as another claim, so a lost reply loses nothing. The fifth claim of a delivery never acknowledged makes it undeliverable instead. With nothing there, a receive waits about 25 seconds and answers with no deliveries; a delivery for its ship or type wakes it at once. `ship.ack` takes `{ "deliveryId": "dlv_..." }` and answers `{}`: only the ship holding the delivery in flight acknowledges it, and acknowledging it again is OK. `ship.pong` takes the crew token and the same scope, takes `{ "deliveryId": "dlv_..." }` of a ping the ship holds in flight and answers `{}`: it acknowledges the ping, with `answer: pong` in `DeliveryAcknowledged`, and marks the lease last seen, in one transaction; again is OK and changes nothing, and a delivery that is not a ping is refused (`CONFLICT`). `ship.report` takes the crew token and no scope: `{ "state": "working" | "blocked" | "idle", "note"?: "..." }` (one line, at most 200 characters, trimmed), answers `{}`. The report is kept with the crew's lease, so the ship's next crew starts with none, and `fleet.list` and `fleet.ship` show it (`report: { state, note, reportedAt }` or null); `ShipReported` is written only when the state or the note changes, so reporting the same again is a check-in. `ship.inbox` takes the crew token and the same scope, takes `{ "waitSeconds": 0 to 25 }`, none when left out, and answers `{ "waiting": n }`: how many deliveries the crew's next receive would hand it, its own in flight included. It claims nothing. While none waits it waits up to `waitSeconds`, woken like a receive. A mutation only so REST takes its body; it changes nothing.
+`ship.receive` and `ship.ack` take the crew token only (the console session is refused) and need the `messages:receive` scope. `ship.receive` takes `{ "max": 1 to 10 }`, one when left out, and answers `{ "deliveries": [...] }`: the crew's own unacknowledged deliveries in flight first, then the oldest pending ones for its ship or its type. Each comes with its message and its sender (`deliveryId`, `messageId`, `senderShipId`, `senderName`, `senderType`, `recipient`, `payload`, `contentType`, `inReplyTo`, `sentAt`, `attempts`; the sender's name and type as they are at the receive, so a renamed sender goes by its new name) and is handed at once: in flight with the crew until acknowledged or the lease ends. The crew's next receive hands it again, counted as another attempt, so a lost reply loses nothing. The fifth attempt of a delivery never acknowledged is refused: it becomes undeliverable instead and is handed to no one. With nothing there, a receive waits about 25 seconds and answers with no deliveries; a delivery for its ship or type wakes it at once. **Unreleased, next version:** `ship.pushReceive`, `ship.handed`, `ship.handled` and `ship.turn` are not available in npm 0.24.0. `ship.pushReceive` (decision 0040), for a pushed ship's trierarch or plugin watcher, takes the same input as `ship.receive` and answers the same deliveries, each with `state` (`received` or `handed`) and `handOverNumber`: a pending one becomes received, in flight with the crew, with no attempt counted; the crew's own received and handed ones come first again, unchanged. From the lease's first push receive until it ends, `ship.receive` answers no deliveries. `ship.handed` takes `{ "deliveryId": "dlv_...", "handOverNumber": n }` and answers `{ "state": "handed" | "acknowledged" | "undeliverable" }`: a number higher than the last counts one attempt, the same or a lower one changes nothing, and the fifth attempt is undeliverable; with `"isOnceMore": true` it hands an acknowledged delivery once more after its turn died, counting no attempt, only once. `ship.handled` and `ship.notHandled` take `{ "deliveryId": "dlv_..." }` and answer `{}`: the turn that took an acknowledged delivery ended by itself, or the turn it was handed once more to died too; again is OK, and a delivery not acknowledged, or not handed once more for `notHandled`, is refused (`CONFLICT`). `ship.ack` takes `{ "deliveryId": "dlv_..." }` and answers `{}`: only the ship holding the delivery in flight, received or handed, acknowledges it, and acknowledging it again is OK. `ship.pong` takes the crew token and the same scope, takes `{ "deliveryId": "dlv_..." }` of a ping the ship holds in flight and answers `{}`: it acknowledges the ping, with `answer: pong` in `DeliveryAcknowledged`, and marks the lease last seen, in one transaction; again is OK and changes nothing, and a delivery that is not a ping is refused (`CONFLICT`). `ship.report` takes the crew token and no scope: `{ "state": "working" | "blocked" | "idle", "note"?: "..." }` (one line, at most 200 characters, trimmed), answers `{}`. The report is kept with the crew's lease, so the ship's next crew starts with none, and `fleet.list` and `fleet.ship` show it (`report: { state, note, reportedAt }` or null); `ShipReported` is written only when the state or the note changes, so reporting the same again is a check-in. `ship.turn` takes the crew token and no scope: `{ "turn": "idle" | "busy", "at": "<ISO 8601>" }`, answers `{}`; the lease keeps the turn at that time with `TurnReported`, and the same turn again or a report older than the one held changes nothing. `ship.inbox` takes the crew token and the same scope, takes `{ "waitSeconds": 0 to 25 }`, none when left out, and answers `{ "waiting": n }`: how many deliveries the crew's next receive would hand it, its own in flight included. It claims nothing. While none waits it waits up to `waitSeconds`, woken like a receive. A mutation only so REST takes its body; it changes nothing.
 
 A lease ends cleanly in two ways. The operator releases a crewed ship with `fleet.release` (`{ "shipId": "shp_..." }`, scope `fleet:manage`); `argo` is never released, and a ship awaiting crew gets a new starting prompt instead (`CONFLICT`). A crew ends its own lease with `ship.deregister`, which takes the crew token only and no scope. Both work in one transaction: the secret is invalidated, the lease and its crew token end, and the deliveries the lease held in flight return to pending, to the ship's inbox or its type's queue, their attempts kept, each announced on `aeolus_delivery_pending` as a send is, so a waiting receive of another ship of the type takes a returned type delivery at once. Both answer `{}`. The old crew token then fails on every call, refused as `LEASE_ENDED` with `This ship was released; this session no longer crews it.` (the `UNAUTHORIZED` code at `/trpc`, which knows only tRPC's codes), and the old secret fails on `register`; the next crew needs a new starting prompt. A receive of that crew still waiting hands out nothing: it answers empty at the end of its wait, or `LEASE_ENDED` if a delivery wakes it first.
 
@@ -74,14 +74,14 @@ A lease ends cleanly in two ways. The operator releases a crewed ship with `flee
 
 The operator retires a ship for good with `fleet.retire` (`{ "shipId": "shp_..." }`, scope `fleet:manage`), crewed or not, never `argo` (`FORBIDDEN`), never twice (`CONFLICT`). In one transaction it locks the ship, invalidates its secret, ends a crewed ship's lease as a release does, abandons the deliveries pending to the ship itself (one `DeliveryAbandoned` each, with `ShipRetired`) and retires it: it is never claimed or addressed again and its name is free. Deliveries to its type stay for the other ships of the type, and an undeliverable one stays for the operator. A send racing it either commits first and is abandoned, or comes after and is refused. It answers `{ "abandonedDeliveries": n }`. `fleet.recrew` (`{ "shipId": "shp_..." }`, `fleet:manage`) gives a crewed ship whose session is gone a new crew: a release and a new starting prompt in one transaction, answering the prompt and crew line once, as `fleet.getStartingPrompt` does. `fleet.ship` counts `inFlightDeliveries` (what a release returns) and `openDeliveries` (what a retire abandons).
 
-Needs attention: `fleet.needsAttention` (`fleet:read`) lists every undeliverable delivery of the fleet, oldest first by when it became undeliverable, each with its claims, `since` and its whole message. `fleet.dismiss` (`{ "deliveryId": "dlv_..." }`, `fleet:manage`) sets one to dismissed with `DeliveryDismissed`, and answers `{}`; again is OK. `fleet.resend` (`{ "deliveryId": "dlv_..." }`, `fleet:manage`) sends it again: a new message from the original sender, to the same ship or type, with the same payload, content type and `inReplyTo`, naming the original (`resend_of`), and dismisses the original, in one transaction. It answers `{ "messageId": "msg_..." }`; a second resend of the delivery answers the same. Any delivery not undeliverable is refused (`CONFLICT`); a selector that no longer resolves is refused as a send would be, and the original stays undeliverable.
+Needs attention: `fleet.needsAttention` (`fleet:read`) lists every undeliverable delivery of the fleet, oldest first by when it became undeliverable, each with its attempts, `since` and its whole message. `fleet.dismiss` (`{ "deliveryId": "dlv_..." }`, `fleet:manage`) sets one to dismissed with `DeliveryDismissed`, and answers `{}`; again is OK. `fleet.resend` (`{ "deliveryId": "dlv_..." }`, `fleet:manage`) sends it again: a new message from the original sender, to the same ship or type, with the same payload, content type and `inReplyTo`, naming the original (`resend_of`), and dismisses the original, in one transaction. It answers `{ "messageId": "msg_..." }`; a second resend of the delivery answers the same. Any delivery not undeliverable is refused (`CONFLICT`); a selector that no longer resolves is refused as a send would be, and the original stays undeliverable. `fleet.overdue` (`fleet:read`) lists the deliveries argo was told are overdue by the 10 and 60 minute clocks (decision 0040), oldest told first: each with its ship, `state`, `clock` (`notConfirmed`, `idle`, `busy`), `minutes`, `toldAt` and its whole message, while it is still in that state on an open lease. Core passes the clocks every 30 seconds while it serves, writing `DeliveryOverdue` once per lease and delivery.
 
-The operator inbox: `fleet.inbox` (`{ "filter": "open" | "done" | "all" }`, `fleet:read`) lists the messages addressed to the caller itself (argo's, for the console; argo's too for a viewer session, decision 0022), newest first, each with its delivery's state, `readAt`, `doneAt`, `repliedWith` and its whole message. Only argo's console session calls the rest; any other ship is refused (`FORBIDDEN`), and a delivery not in argo's inbox is `NOT_FOUND`. `fleet.markRead` (`{ "deliveryId", "isRead" }`, `messages:receive`) marks it read (keeping the first read) or unread; read is not done, and no event is written. `fleet.markDone` (`{ "deliveryId" }`, `messages:receive`) claims and acknowledges it at once under the console session's lease; again is OK. `fleet.reply` (`{ "deliveryId", "payload", "idempotencyKey" }`, `messages:send` and `messages:receive`) sends the payload as `text/plain` from argo to the message's sender with `inReplyTo`, and marks the message done in one transaction; it answers `{ "messageId" }`, and a repeat of the key answers the same reply.
+The operator inbox: `fleet.inbox` (`{ "filter": "open" | "done" | "all" }`, `fleet:read`) lists the messages addressed to the caller itself (argo's, for the console; argo's too for a viewer session, decision 0022), newest first, each with its delivery's state, `readAt`, `doneAt`, `repliedWith` and its whole message. Only argo's console session calls the rest; any other ship is refused (`FORBIDDEN`), and a delivery not in argo's inbox is `NOT_FOUND`. `fleet.markRead` (`{ "deliveryId", "isRead" }`, `messages:receive`) marks it read (keeping the first read) or unread; read is not done, and no event is written. `fleet.markDone` (`{ "deliveryId" }`, `messages:receive`) hands and acknowledges it at once under the console session's lease; again is OK. `fleet.reply` (`{ "deliveryId", "payload", "idempotencyKey" }`, `messages:send` and `messages:receive`) sends the payload as `text/plain` from argo to the message's sender with `inReplyTo`, and marks the message done in one transaction; it answers `{ "messageId" }`, and a repeat of the key answers the same reply.
 
 A ship reaches the same calls without installing anything, as REST under `/api/v1` or as MCP tools at `/mcp`. Both map onto the ship procedures above and hold no logic of their own; neither reads the console session cookie, so a call without a valid crew token is told to use the crew token alone, and failed `register` attempts count against one limit per client address whichever door they come through. A failure in either door, inside a procedure or not, answers only `Internal error` and the request's id. The MCP server sends the ship protocol (`adapters/trpc/ship-protocol.ts`) as its instructions when a client connects, and the OpenAPI spec's description opens with the same text: register once, at the start, and keep the crew token; then receive, ack each delivery and act only if the ack succeeded, and answer by `senderName` with `inReplyTo`; keep receiving while waiting for an answer; deregister only when the session ends for good; end the turn when the work is done and no answer is expected; and once a call answers `LEASE_ENDED`, stop calling the fleet. Each call's description states only that call's own rules, such as `inReplyTo` taking the message id and a new idempotency key for every message; no rule is stated in both.
 
-- **REST**: `POST /api/v1/ship/register`, `GET /api/v1/ship/whoami`, and `POST /api/v1/ship/send`, `/receive`, `/ack`, `/inbox` and `/deregister`, each with a JSON body where it takes input and the crew token as `Authorization: Bearer`. A refusal answers with its code's HTTP status and `{ "code": "CONFLICT", "message": "..." }`. The OpenAPI 3.1 spec is at `/api/v1/openapi.json`, and as a readable page at `/api/v1/docs`.
-- **MCP**: a remote MCP server over streamable HTTP, one tool per call. The connection carries no ship, so many conversations can share it (ADR 0015): every tool but `register` takes the crew token as its `crewToken` argument. A refusal is a tool error reading `CODE: message`. To add it to Claude Code, for every session on the machine: `claude mcp add --transport http --scope user aeolus <PUBLIC_URL>/mcp`.
+- **REST**: `POST /api/v1/ship/register`, `GET /api/v1/ship/whoami`, and `POST /api/v1/ship/send`, `/receive`, `/pushReceive`, `/handed`, `/handled`, `/notHandled`, `/ack`, `/turn`, `/inbox` and `/deregister`, each with a JSON body where it takes input and the crew token as `Authorization: Bearer`. A refusal answers with its code's HTTP status and `{ "code": "CONFLICT", "message": "..." }`. The OpenAPI 3.1 spec is at `/api/v1/openapi.json`, and as a readable page at `/api/v1/docs`.
+- **MCP**: a remote MCP server over streamable HTTP, one tool per call. The connection carries no ship, so many conversations can share it (ADR 0015): every tool but `register` takes the crew token as its `crewToken` argument. A refusal is a tool error reading `CODE: message`. To add it to Claude Code, for every session on the machine: `claude mcp add --transport http --scope user aeolus <PUBLIC_URL>/mcp`. A chat app (Claude chat, ChatGPT) connects `<PUBLIC_URL>/mcp` as a remote MCP server or connector, without auth.
 
 The server listens on `aeolus_delivery_pending` over a connection of its own (named `aeolus-delivery-listener` in Postgres), which needs a direct database connection, not a transaction pooler. After a lost connection it listens again, with a delay that doubles up to 30 seconds, and every waiting receive then looks again, since notices sent meanwhile are gone.
 

package/dist/adapters/prisma/generated/browser.d.ts

@@ -99,15 +99,24 @@ export type Message = Prisma.MessageModel;
 /**
  * Model Delivery
  * One message to one resolved recipient: a ship or a type. Ids start with dlv_.
- * A receive claims it for the ship and the lease of the crew receiving: set while it
- * is in flight, kept once acknowledged, none while it is pending. Attempts count the
- * claims; the fifth makes it undeliverable.
+ * A receive hands it to the ship and the lease of the crew receiving, or a push
+ * receive takes it for them: set while it is received or handed, kept once
+ * acknowledged, none while it is pending. Attempts count the hand-overs; the fifth
+ * makes it undeliverable. The hand-over number is the last one the crew reported
+ * with handed (decision 0040), none while pending.
  * The read date is set when the operator opens a message to argo.
  * For a type under network rules, the ships of the type its sender may reach,
  * fixed at send time: only they claim it (decision 0034). Empty: any ship of
  * the type, as a send no ship of the type may take is refused.
  */
 export type Delivery = Prisma.DeliveryModel;
+/**
+ * Model OverdueDelivery
+ * A delivery argo was told is overdue on a pushed lease: its clock ran out
+ * while it waited in the state kept here. Once per lease and delivery, so a
+ * pass after a restart, or a second pass at once, tells nothing again.
+ */
+export type OverdueDelivery = Prisma.OverdueDeliveryModel;
 /**
  * Model Event
  * Append-only log of every state change: never updated or deleted. Ids start with evt_.

package/dist/adapters/prisma/generated/client.d.ts

@@ -118,15 +118,24 @@ export type Message = Prisma.MessageModel;
 /**
  * Model Delivery
  * One message to one resolved recipient: a ship or a type. Ids start with dlv_.
- * A receive claims it for the ship and the lease of the crew receiving: set while it
- * is in flight, kept once acknowledged, none while it is pending. Attempts count the
- * claims; the fifth makes it undeliverable.
+ * A receive hands it to the ship and the lease of the crew receiving, or a push
+ * receive takes it for them: set while it is received or handed, kept once
+ * acknowledged, none while it is pending. Attempts count the hand-overs; the fifth
+ * makes it undeliverable. The hand-over number is the last one the crew reported
+ * with handed (decision 0040), none while pending.
  * The read date is set when the operator opens a message to argo.
  * For a type under network rules, the ships of the type its sender may reach,
  * fixed at send time: only they claim it (decision 0034). Empty: any ship of
  * the type, as a send no ship of the type may take is refused.
  */
 export type Delivery = Prisma.DeliveryModel;
+/**
+ * Model OverdueDelivery
+ * A delivery argo was told is overdue on a pushed lease: its clock ran out
+ * while it waited in the state kept here. Once per lease and delivery, so a
+ * pass after a restart, or a second pass at once, tells nothing again.
+ */
+export type OverdueDelivery = Prisma.OverdueDeliveryModel;
 /**
  * Model Event
  * Append-only log of every state change: never updated or deleted. Ids start with evt_.

package/dist/adapters/prisma/generated/commonInputTypes.d.ts

@@ -228,6 +228,12 @@ export type IntFilter<$PrismaModel = never> = {
     gte?: number | Prisma.IntFieldRefInput<$PrismaModel>;
     not?: Prisma.NestedIntFilter<$PrismaModel> | number;
 };
+export type EnumTurnStateNullableFilter<$PrismaModel = never> = {
+    equals?: $Enums.TurnState | Prisma.EnumTurnStateFieldRefInput<$PrismaModel> | null;
+    in?: $Enums.TurnState[] | Prisma.ListEnumTurnStateFieldRefInput<$PrismaModel> | null;
+    notIn?: $Enums.TurnState[] | Prisma.ListEnumTurnStateFieldRefInput<$PrismaModel> | null;
+    not?: Prisma.NestedEnumTurnStateNullableFilter<$PrismaModel> | $Enums.TurnState | null;
+};
 export type EnumLocationKindWithAggregatesFilter<$PrismaModel = never> = {
     equals?: $Enums.LocationKind | Prisma.EnumLocationKindFieldRefInput<$PrismaModel>;
     in?: $Enums.LocationKind[] | Prisma.ListEnumLocationKindFieldRefInput<$PrismaModel>;
@@ -281,6 +287,15 @@ export type IntWithAggregatesFilter<$PrismaModel = never> = {
     _min?: Prisma.NestedIntFilter<$PrismaModel>;
     _max?: Prisma.NestedIntFilter<$PrismaModel>;
 };
+export type EnumTurnStateNullableWithAggregatesFilter<$PrismaModel = never> = {
+    equals?: $Enums.TurnState | Prisma.EnumTurnStateFieldRefInput<$PrismaModel> | null;
+    in?: $Enums.TurnState[] | Prisma.ListEnumTurnStateFieldRefInput<$PrismaModel> | null;
+    notIn?: $Enums.TurnState[] | Prisma.ListEnumTurnStateFieldRefInput<$PrismaModel> | null;
+    not?: Prisma.NestedEnumTurnStateNullableWithAggregatesFilter<$PrismaModel> | $Enums.TurnState | null;
+    _count?: Prisma.NestedIntNullableFilter<$PrismaModel>;
+    _min?: Prisma.NestedEnumTurnStateNullableFilter<$PrismaModel>;
+    _max?: Prisma.NestedEnumTurnStateNullableFilter<$PrismaModel>;
+};
 export type JsonFilter<$PrismaModel = never> = Prisma.PatchUndefined<Prisma.Either<Required<JsonFilterBase<$PrismaModel>>, Exclude<keyof Required<JsonFilterBase<$PrismaModel>>, 'path'>>, Required<JsonFilterBase<$PrismaModel>>> | Prisma.OptionalFlat<Omit<Required<JsonFilterBase<$PrismaModel>>, 'path'>>;
 export type JsonFilterBase<$PrismaModel = never> = {
     equals?: runtime.InputJsonValue | Prisma.JsonFieldRefInput<$PrismaModel> | Prisma.JsonNullValueFilter;
@@ -363,6 +378,21 @@ export type EnumDeliveryStateWithAggregatesFilter<$PrismaModel = never> = {
     _min?: Prisma.NestedEnumDeliveryStateFilter<$PrismaModel>;
     _max?: Prisma.NestedEnumDeliveryStateFilter<$PrismaModel>;
 };
+export type EnumOverdueClockFilter<$PrismaModel = never> = {
+    equals?: $Enums.OverdueClock | Prisma.EnumOverdueClockFieldRefInput<$PrismaModel>;
+    in?: $Enums.OverdueClock[] | Prisma.ListEnumOverdueClockFieldRefInput<$PrismaModel>;
+    notIn?: $Enums.OverdueClock[] | Prisma.ListEnumOverdueClockFieldRefInput<$PrismaModel>;
+    not?: Prisma.NestedEnumOverdueClockFilter<$PrismaModel> | $Enums.OverdueClock;
+};
+export type EnumOverdueClockWithAggregatesFilter<$PrismaModel = never> = {
+    equals?: $Enums.OverdueClock | Prisma.EnumOverdueClockFieldRefInput<$PrismaModel>;
+    in?: $Enums.OverdueClock[] | Prisma.ListEnumOverdueClockFieldRefInput<$PrismaModel>;
+    notIn?: $Enums.OverdueClock[] | Prisma.ListEnumOverdueClockFieldRefInput<$PrismaModel>;
+    not?: Prisma.NestedEnumOverdueClockWithAggregatesFilter<$PrismaModel> | $Enums.OverdueClock;
+    _count?: Prisma.NestedIntFilter<$PrismaModel>;
+    _min?: Prisma.NestedEnumOverdueClockFilter<$PrismaModel>;
+    _max?: Prisma.NestedEnumOverdueClockFilter<$PrismaModel>;
+};
 export type EnumThemeFilter<$PrismaModel = never> = {
     equals?: $Enums.Theme | Prisma.EnumThemeFieldRefInput<$PrismaModel>;
     in?: $Enums.Theme[] | Prisma.ListEnumThemeFieldRefInput<$PrismaModel>;
@@ -675,6 +705,12 @@ export type NestedEnumReportStateNullableFilter<$PrismaModel = never> = {
     notIn?: $Enums.ReportState[] | Prisma.ListEnumReportStateFieldRefInput<$PrismaModel> | null;
     not?: Prisma.NestedEnumReportStateNullableFilter<$PrismaModel> | $Enums.ReportState | null;
 };
+export type NestedEnumTurnStateNullableFilter<$PrismaModel = never> = {
+    equals?: $Enums.TurnState | Prisma.EnumTurnStateFieldRefInput<$PrismaModel> | null;
+    in?: $Enums.TurnState[] | Prisma.ListEnumTurnStateFieldRefInput<$PrismaModel> | null;
+    notIn?: $Enums.TurnState[] | Prisma.ListEnumTurnStateFieldRefInput<$PrismaModel> | null;
+    not?: Prisma.NestedEnumTurnStateNullableFilter<$PrismaModel> | $Enums.TurnState | null;
+};
 export type NestedEnumLocationKindWithAggregatesFilter<$PrismaModel = never> = {
     equals?: $Enums.LocationKind | Prisma.EnumLocationKindFieldRefInput<$PrismaModel>;
     in?: $Enums.LocationKind[] | Prisma.ListEnumLocationKindFieldRefInput<$PrismaModel>;
@@ -725,6 +761,15 @@ export type NestedIntWithAggregatesFilter<$PrismaModel = never> = {
     _min?: Prisma.NestedIntFilter<$PrismaModel>;
     _max?: Prisma.NestedIntFilter<$PrismaModel>;
 };
+export type NestedEnumTurnStateNullableWithAggregatesFilter<$PrismaModel = never> = {
+    equals?: $Enums.TurnState | Prisma.EnumTurnStateFieldRefInput<$PrismaModel> | null;
+    in?: $Enums.TurnState[] | Prisma.ListEnumTurnStateFieldRefInput<$PrismaModel> | null;
+    notIn?: $Enums.TurnState[] | Prisma.ListEnumTurnStateFieldRefInput<$PrismaModel> | null;
+    not?: Prisma.NestedEnumTurnStateNullableWithAggregatesFilter<$PrismaModel> | $Enums.TurnState | null;
+    _count?: Prisma.NestedIntNullableFilter<$PrismaModel>;
+    _min?: Prisma.NestedEnumTurnStateNullableFilter<$PrismaModel>;
+    _max?: Prisma.NestedEnumTurnStateNullableFilter<$PrismaModel>;
+};
 export type NestedEnumCrewStatusNullableFilter<$PrismaModel = never> = {
     equals?: $Enums.CrewStatus | Prisma.EnumCrewStatusFieldRefInput<$PrismaModel> | null;
     in?: $Enums.CrewStatus[] | Prisma.ListEnumCrewStatusFieldRefInput<$PrismaModel> | null;
@@ -787,6 +832,21 @@ export type NestedEnumDeliveryStateWithAggregatesFilter<$PrismaModel = never> =
     _min?: Prisma.NestedEnumDeliveryStateFilter<$PrismaModel>;
     _max?: Prisma.NestedEnumDeliveryStateFilter<$PrismaModel>;
 };
+export type NestedEnumOverdueClockFilter<$PrismaModel = never> = {
+    equals?: $Enums.OverdueClock | Prisma.EnumOverdueClockFieldRefInput<$PrismaModel>;
+    in?: $Enums.OverdueClock[] | Prisma.ListEnumOverdueClockFieldRefInput<$PrismaModel>;
+    notIn?: $Enums.OverdueClock[] | Prisma.ListEnumOverdueClockFieldRefInput<$PrismaModel>;
+    not?: Prisma.NestedEnumOverdueClockFilter<$PrismaModel> | $Enums.OverdueClock;
+};
+export type NestedEnumOverdueClockWithAggregatesFilter<$PrismaModel = never> = {
+    equals?: $Enums.OverdueClock | Prisma.EnumOverdueClockFieldRefInput<$PrismaModel>;
+    in?: $Enums.OverdueClock[] | Prisma.ListEnumOverdueClockFieldRefInput<$PrismaModel>;
+    notIn?: $Enums.OverdueClock[] | Prisma.ListEnumOverdueClockFieldRefInput<$PrismaModel>;
+    not?: Prisma.NestedEnumOverdueClockWithAggregatesFilter<$PrismaModel> | $Enums.OverdueClock;
+    _count?: Prisma.NestedIntFilter<$PrismaModel>;
+    _min?: Prisma.NestedEnumOverdueClockFilter<$PrismaModel>;
+    _max?: Prisma.NestedEnumOverdueClockFilter<$PrismaModel>;
+};
 export type NestedEnumThemeFilter<$PrismaModel = never> = {
     equals?: $Enums.Theme | Prisma.EnumThemeFieldRefInput<$PrismaModel>;
     in?: $Enums.Theme[] | Prisma.ListEnumThemeFieldRefInput<$PrismaModel>;

package/dist/adapters/prisma/generated/enums.d.ts

@@ -10,6 +10,11 @@ export declare const ReportState: {
     readonly idle: "idle";
 };
 export type ReportState = (typeof ReportState)[keyof typeof ReportState];
+export declare const TurnState: {
+    readonly idle: "idle";
+    readonly busy: "busy";
+};
+export type TurnState = (typeof TurnState)[keyof typeof TurnState];
 export declare const LocationKind: {
     readonly DEVICE: "DEVICE";
     readonly CLOUD: "CLOUD";
@@ -32,13 +37,22 @@ export declare const SelectorKind: {
 export type SelectorKind = (typeof SelectorKind)[keyof typeof SelectorKind];
 export declare const DeliveryState: {
     readonly pending: "pending";
-    readonly delivered: "delivered";
+    readonly received: "received";
+    readonly handed: "handed";
     readonly acknowledged: "acknowledged";
+    readonly handled: "handled";
+    readonly notHandled: "notHandled";
     readonly undeliverable: "undeliverable";
     readonly dismissed: "dismissed";
     readonly abandoned: "abandoned";
 };
 export type DeliveryState = (typeof DeliveryState)[keyof typeof DeliveryState];
+export declare const OverdueClock: {
+    readonly notConfirmed: "notConfirmed";
+    readonly idle: "idle";
+    readonly busy: "busy";
+};
+export type OverdueClock = (typeof OverdueClock)[keyof typeof OverdueClock];
 export declare const ConsoleSessionEndReason: {
     readonly takenOver: "takenOver";
     readonly signedOut: "signedOut";

package/dist/adapters/prisma/generated/enums.js

@@ -17,6 +17,10 @@ export const ReportState = {
     blocked: 'blocked',
     idle: 'idle'
 };
+export const TurnState = {
+    idle: 'idle',
+    busy: 'busy'
+};
 export const LocationKind = {
     DEVICE: 'DEVICE',
     CLOUD: 'CLOUD',
@@ -36,12 +40,20 @@ export const SelectorKind = {
 };
 export const DeliveryState = {
     pending: 'pending',
-    delivered: 'delivered',
+    received: 'received',
+    handed: 'handed',
     acknowledged: 'acknowledged',
+    handled: 'handled',
+    notHandled: 'notHandled',
     undeliverable: 'undeliverable',
     dismissed: 'dismissed',
     abandoned: 'abandoned'
 };
+export const OverdueClock = {
+    notConfirmed: 'notConfirmed',
+    idle: 'idle',
+    busy: 'busy'
+};
 export const ConsoleSessionEndReason = {
     takenOver: 'takenOver',
     signedOut: 'signedOut',

package/dist/adapters/prisma/generated/enums.js.map

@@ -1 +1 @@
-{"version":3,"file":"enums.js","sourceRoot":"","sources":["../../../../src/adapters/prisma/generated/enums.ts"],"names":[],"mappings":"AACA,qEAAqE;AACrE,oBAAoB;AACpB,wCAAwC;AACxC,eAAe;AACf;;;;EAIE;AAEF,MAAM,CAAC,MAAM,QAAQ,GAAG;IACtB,QAAQ,EAAE,UAAU;IACpB,KAAK,EAAE,OAAO;IACd,MAAM,EAAE,QAAQ;CACR,CAAA;AAKV,MAAM,CAAC,MAAM,WAAW,GAAG;IACzB,OAAO,EAAE,SAAS;IAClB,OAAO,EAAE,SAAS;IAClB,IAAI,EAAE,MAAM;CACJ,CAAA;AAKV,MAAM,CAAC,MAAM,YAAY,GAAG;IAC1B,MAAM,EAAE,QAAQ;IAChB,KAAK,EAAE,OAAO;IACd,MAAM,EAAE,QAAQ;IAChB,KAAK,EAAE,OAAO;CACN,CAAA;AAKV,MAAM,CAAC,MAAM,UAAU,GAAG;IACxB,OAAO,EAAE,SAAS;IAClB,OAAO,EAAE,SAAS;IAClB,UAAU,EAAE,YAAY;IACxB,OAAO,EAAE,SAAS;IAClB,SAAS,EAAE,WAAW;CACd,CAAA;AAKV,MAAM,CAAC,MAAM,YAAY,GAAG;IAC1B,IAAI,EAAE,MAAM;IACZ,IAAI,EAAE,MAAM;CACJ,CAAA;AAKV,MAAM,CAAC,MAAM,aAAa,GAAG;IAC3B,OAAO,EAAE,SAAS;IAClB,SAAS,EAAE,WAAW;IACtB,YAAY,EAAE,cAAc;IAC5B,aAAa,EAAE,eAAe;IAC9B,SAAS,EAAE,WAAW;IACtB,SAAS,EAAE,WAAW;CACd,CAAA;AAKV,MAAM,CAAC,MAAM,uBAAuB,GAAG;IACrC,SAAS,EAAE,WAAW;IACtB,SAAS,EAAE,WAAW;IACtB,aAAa,EAAE,eAAe;CACtB,CAAA;AAKV,MAAM,CAAC,MAAM,KAAK,GAAG;IACnB,KAAK,EAAE,OAAO;IACd,IAAI,EAAE,MAAM;IACZ,MAAM,EAAE,QAAQ;CACR,CAAA;AAKV,MAAM,CAAC,MAAM,QAAQ,GAAG;IACtB,QAAQ,EAAE,UAAU;IACpB,MAAM,EAAE,QAAQ;CACR,CAAA;AAKV,MAAM,CAAC,MAAM,uBAAuB,GAAG;IACrC,WAAW,EAAE,aAAa;IAC1B,WAAW,EAAE,aAAa;CAClB,CAAA;AAKV,MAAM,CAAC,MAAM,cAAc,GAAG;IAC5B,QAAQ,EAAE,UAAU;IACpB,SAAS,EAAE,WAAW;IACtB,OAAO,EAAE,SAAS;CACV,CAAA;AAKV,MAAM,CAAC,MAAM,kBAAkB,GAAG;IAChC,IAAI,EAAE,MAAM;IACZ,OAAO,EAAE,SAAS;IAClB,QAAQ,EAAE,UAAU;CACZ,CAAA"}
+{"version":3,"file":"enums.js","sourceRoot":"","sources":["../../../../src/adapters/prisma/generated/enums.ts"],"names":[],"mappings":"AACA,qEAAqE;AACrE,oBAAoB;AACpB,wCAAwC;AACxC,eAAe;AACf;;;;EAIE;AAEF,MAAM,CAAC,MAAM,QAAQ,GAAG;IACtB,QAAQ,EAAE,UAAU;IACpB,KAAK,EAAE,OAAO;IACd,MAAM,EAAE,QAAQ;CACR,CAAA;AAKV,MAAM,CAAC,MAAM,WAAW,GAAG;IACzB,OAAO,EAAE,SAAS;IAClB,OAAO,EAAE,SAAS;IAClB,IAAI,EAAE,MAAM;CACJ,CAAA;AAKV,MAAM,CAAC,MAAM,SAAS,GAAG;IACvB,IAAI,EAAE,MAAM;IACZ,IAAI,EAAE,MAAM;CACJ,CAAA;AAKV,MAAM,CAAC,MAAM,YAAY,GAAG;IAC1B,MAAM,EAAE,QAAQ;IAChB,KAAK,EAAE,OAAO;IACd,MAAM,EAAE,QAAQ;IAChB,KAAK,EAAE,OAAO;CACN,CAAA;AAKV,MAAM,CAAC,MAAM,UAAU,GAAG;IACxB,OAAO,EAAE,SAAS;IAClB,OAAO,EAAE,SAAS;IAClB,UAAU,EAAE,YAAY;IACxB,OAAO,EAAE,SAAS;IAClB,SAAS,EAAE,WAAW;CACd,CAAA;AAKV,MAAM,CAAC,MAAM,YAAY,GAAG;IAC1B,IAAI,EAAE,MAAM;IACZ,IAAI,EAAE,MAAM;CACJ,CAAA;AAKV,MAAM,CAAC,MAAM,aAAa,GAAG;IAC3B,OAAO,EAAE,SAAS;IAClB,QAAQ,EAAE,UAAU;IACpB,MAAM,EAAE,QAAQ;IAChB,YAAY,EAAE,cAAc;IAC5B,OAAO,EAAE,SAAS;IAClB,UAAU,EAAE,YAAY;IACxB,aAAa,EAAE,eAAe;IAC9B,SAAS,EAAE,WAAW;IACtB,SAAS,EAAE,WAAW;CACd,CAAA;AAKV,MAAM,CAAC,MAAM,YAAY,GAAG;IAC1B,YAAY,EAAE,cAAc;IAC5B,IAAI,EAAE,MAAM;IACZ,IAAI,EAAE,MAAM;CACJ,CAAA;AAKV,MAAM,CAAC,MAAM,uBAAuB,GAAG;IACrC,SAAS,EAAE,WAAW;IACtB,SAAS,EAAE,WAAW;IACtB,aAAa,EAAE,eAAe;CACtB,CAAA;AAKV,MAAM,CAAC,MAAM,KAAK,GAAG;IACnB,KAAK,EAAE,OAAO;IACd,IAAI,EAAE,MAAM;IACZ,MAAM,EAAE,QAAQ;CACR,CAAA;AAKV,MAAM,CAAC,MAAM,QAAQ,GAAG;IACtB,QAAQ,EAAE,UAAU;IACpB,MAAM,EAAE,QAAQ;CACR,CAAA;AAKV,MAAM,CAAC,MAAM,uBAAuB,GAAG;IACrC,WAAW,EAAE,aAAa;IAC1B,WAAW,EAAE,aAAa;CAClB,CAAA;AAKV,MAAM,CAAC,MAAM,cAAc,GAAG;IAC5B,QAAQ,EAAE,UAAU;IACpB,SAAS,EAAE,WAAW;IACtB,OAAO,EAAE,SAAS;CACV,CAAA;AAKV,MAAM,CAAC,MAAM,kBAAkB,GAAG;IAChC,IAAI,EAAE,MAAM;IACZ,OAAO,EAAE,SAAS;IAClB,QAAQ,EAAE,UAAU;CACZ,CAAA"}

package/dist/adapters/prisma/generated/internal/class.d.ts

@@ -282,6 +282,17 @@ export interface PrismaClient<in LogOpts extends Prisma.LogLevel = never, in out
     get delivery(): Prisma.DeliveryDelegate<ExtArgs, {
         omit: OmitOpts;
     }>;
+    /**
+     * `prisma.overdueDelivery`: Exposes CRUD operations for the **OverdueDelivery** model.
+      * Example usage:
+      * ```ts
+      * // Fetch zero or more OverdueDeliveries
+      * const overdueDeliveries = await prisma.overdueDelivery.findMany()
+      * ```
+      */
+    get overdueDelivery(): Prisma.OverdueDeliveryDelegate<ExtArgs, {
+        omit: OmitOpts;
+    }>;
     /**
      * `prisma.event`: Exposes CRUD operations for the **Event** model.
       * Example usage: