refactor: add agent_id to various interfaces and improve field organization

backend/app/api/board_webhooks.py

@@ -64,6 +64,7 @@ def _to_webhook_read(webhook: BoardWebhook) -> BoardWebhookRead:
     return BoardWebhookRead(
         id=webhook.id,
         board_id=webhook.board_id,
+        agent_id=webhook.agent_id,
         description=webhook.description,
         enabled=webhook.enabled,
         endpoint_path=endpoint_path,
@@ -206,12 +207,18 @@ async def _notify_lead_on_webhook_payload(
     webhook: BoardWebhook,
     payload: BoardWebhookPayload,
 ) -> None:
-    lead = (
+    target_agent: Agent | None = None
-        await Agent.objects.filter_by(board_id=board.id)
+    if webhook.agent_id is not None:
-        .filter(col(Agent.is_board_lead).is_(True))
+        target_agent = await Agent.objects.filter_by(id=webhook.agent_id, board_id=board.id).first(
-        .first(session)
+            session
-    )
+        )
-    if lead is None or not lead.openclaw_session_id:
+    if target_agent is None:
+        target_agent = (
+            await Agent.objects.filter_by(board_id=board.id)
+            .filter(col(Agent.is_board_lead).is_(True))
+            .first(session)
+        )
+    if target_agent is None or not target_agent.openclaw_session_id:
         return
 
     dispatch = GatewayDispatchService(session)
@@ -236,14 +243,30 @@ async def _notify_lead_on_webhook_payload(
         f"GET /api/v1/agent/boards/{board.id}/memory?is_chat=false"
     )
     await dispatch.try_send_agent_message(
-        session_key=lead.openclaw_session_id,
+        session_key=target_agent.openclaw_session_id,
         config=config,
-        agent_name=lead.name,
+        agent_name=target_agent.name,
         message=message,
         deliver=False,
     )
 
 
+async def _validate_agent_id(
+    *,
+    session: AsyncSession,
+    board: Board,
+    agent_id: UUID | None,
+) -> None:
+    if agent_id is None:
+        return
+    agent = await Agent.objects.filter_by(id=agent_id, board_id=board.id).first(session)
+    if agent is None:
+        raise HTTPException(
+            status_code=status.HTTP_422_UNPROCESSABLE_ENTITY,
+            detail="agent_id must reference an agent on this board.",
+        )
+
+
 @router.get("", response_model=DefaultLimitOffsetPage[BoardWebhookRead])
 async def list_board_webhooks(
     board: Board = BOARD_USER_READ_DEP,
@@ -270,8 +293,14 @@ async def create_board_webhook(
     session: AsyncSession = SESSION_DEP,
 ) -> BoardWebhookRead:
     """Create a new board webhook with a generated UUID endpoint."""
+    await _validate_agent_id(
+        session=session,
+        board=board,
+        agent_id=payload.agent_id,
+    )
     webhook = BoardWebhook(
         board_id=board.id,
+        agent_id=payload.agent_id,
         description=payload.description,
         enabled=payload.enabled,
     )
@@ -309,6 +338,11 @@ async def update_board_webhook(
     )
     updates = payload.model_dump(exclude_unset=True)
     if updates:
+        await _validate_agent_id(
+            session=session,
+            board=board,
+            agent_id=updates.get("agent_id"),
+        )
         crud.apply_updates(webhook, updates)
         webhook.updated_at = utcnow()
         await crud.save(session, webhook)

backend/app/models/board_webhooks.py

@@ -20,6 +20,7 @@ class BoardWebhook(QueryModel, table=True):
 
     id: UUID = Field(default_factory=uuid4, primary_key=True)
     board_id: UUID = Field(foreign_key="boards.id", index=True)
+    agent_id: UUID | None = Field(default=None, foreign_key="agents.id", index=True)
     description: str
     enabled: bool = Field(default=True, index=True)
     created_at: datetime = Field(default_factory=utcnow)

backend/app/schemas/board_webhooks.py

@@ -17,6 +17,7 @@ class BoardWebhookCreate(SQLModel):
 
     description: NonEmptyStr
     enabled: bool = True
+    agent_id: UUID | None = None
 
 
 class BoardWebhookUpdate(SQLModel):
@@ -24,6 +25,7 @@ class BoardWebhookUpdate(SQLModel):
 
     description: NonEmptyStr | None = None
     enabled: bool | None = None
+    agent_id: UUID | None = None
 
 
 class BoardWebhookRead(SQLModel):
@@ -31,6 +33,7 @@ class BoardWebhookRead(SQLModel):
 
     id: UUID
     board_id: UUID
+    agent_id: UUID | None = None
     description: str
     enabled: bool
     endpoint_path: str

backend/app/services/webhooks/dispatch.py

@@ -62,15 +62,23 @@ def _webhook_message(
     )
 
 
-async def _notify_lead(
+async def _notify_target_agent(
     *,
     session: AsyncSession,
     board: Board,
     webhook: BoardWebhook,
     payload: BoardWebhookPayload,
 ) -> None:
-    lead = await Agent.objects.filter_by(board_id=board.id, is_board_lead=True).first(session)
+    target_agent: Agent | None = None
-    if lead is None or not lead.openclaw_session_id:
+    if webhook.agent_id is not None:
+        target_agent = await Agent.objects.filter_by(id=webhook.agent_id, board_id=board.id).first(
+            session
+        )
+    if target_agent is None:
+        target_agent = await Agent.objects.filter_by(board_id=board.id, is_board_lead=True).first(
+            session
+        )
+    if target_agent is None or not target_agent.openclaw_session_id:
         return
 
     dispatch = GatewayDispatchService(session)
@@ -80,9 +88,9 @@ async def _notify_lead(
 
     message = _webhook_message(board=board, webhook=webhook, payload=payload)
     await dispatch.try_send_agent_message(
-        session_key=lead.openclaw_session_id,
+        session_key=target_agent.openclaw_session_id,
         config=config,
-        agent_name=lead.name,
+        agent_name=target_agent.name,
         message=message,
         deliver=False,
     )
@@ -160,7 +168,7 @@ async def _process_single_item(item: QueuedInboundDelivery) -> None:
             return
 
         board, webhook, payload = loaded
-        await _notify_lead(session=session, board=board, webhook=webhook, payload=payload)
+        await _notify_target_agent(session=session, board=board, webhook=webhook, payload=payload)
         await session.commit()
 
 

backend/migrations/versions/b7a1d9c3e4f5_add_agent_id_to_board_webhooks.py

@@ -0,0 +1,38 @@
+"""Add optional agent mapping to board webhooks.
+
+Revision ID: b7a1d9c3e4f5
+Revises: a2f6c9d4b7e8
+Create Date: 2026-02-15 14:00:00.000000
+"""
+
+from __future__ import annotations
+
+import sqlalchemy as sa
+from alembic import op
+
+
+# revision identifiers, used by Alembic.
+revision = "b7a1d9c3e4f5"
+down_revision = "a2f6c9d4b7e8"
+branch_labels = None
+depends_on = None
+
+
+def upgrade() -> None:
+    """Add optional mapped agent reference on board webhooks."""
+    op.add_column("board_webhooks", sa.Column("agent_id", sa.Uuid(), nullable=True))
+    op.create_index("ix_board_webhooks_agent_id", "board_webhooks", ["agent_id"], unique=False)
+    op.create_foreign_key(
+        "fk_board_webhooks_agent_id_agents",
+        "board_webhooks",
+        "agents",
+        ["agent_id"],
+        ["id"],
+    )
+
+
+def downgrade() -> None:
+    """Remove optional mapped agent reference from board webhooks."""
+    op.drop_constraint("fk_board_webhooks_agent_id_agents", "board_webhooks", type_="foreignkey")
+    op.drop_index("ix_board_webhooks_agent_id", table_name="board_webhooks")
+    op.drop_column("board_webhooks", "agent_id")

backend/tests/test_webhook_dispatch.py

@@ -5,6 +5,7 @@ from __future__ import annotations
 
 import json
 from datetime import UTC, datetime
+from types import SimpleNamespace
 from uuid import UUID, uuid4
 
 import pytest
@@ -222,6 +223,128 @@ async def test_dispatch_flush_recovers_from_dequeue_error(monkeypatch: pytest.Mo
     assert processed == 1
 
 
+@pytest.mark.asyncio
+async def test_notify_target_agent_prefers_mapped_agent(monkeypatch: pytest.MonkeyPatch) -> None:
+    agent_id = uuid4()
+    mapped_agent = SimpleNamespace(
+        id=agent_id,
+        name="Mapped Agent",
+        openclaw_session_id="mapped:session",
+    )
+    lead_agent = SimpleNamespace(
+        id=uuid4(),
+        name="Lead Agent",
+        openclaw_session_id="lead:session",
+    )
+    sent: list[dict[str, str]] = []
+
+    class _FakeAgentObjects:
+        def filter_by(self, **kwargs: object) -> _FakeAgentObjects:
+            self._kwargs = kwargs
+            return self
+
+        async def first(self, session: object) -> object | None:
+            del session
+            if self._kwargs.get("id") == agent_id:
+                return mapped_agent
+            if self._kwargs.get("is_board_lead") is True:
+                return lead_agent
+            return None
+
+    class _FakeDispatchService:
+        def __init__(self, session: object) -> None:
+            del session
+
+        async def optional_gateway_config_for_board(self, board: object) -> object:
+            del board
+            return object()
+
+        async def try_send_agent_message(
+            self,
+            *,
+            session_key: str,
+            config: object,
+            agent_name: str,
+            message: str,
+            deliver: bool = False,
+        ) -> None:
+            del config, message, deliver
+            sent.append({"session_key": session_key, "agent_name": agent_name})
+
+    monkeypatch.setattr(dispatch.Agent, "objects", _FakeAgentObjects())
+    monkeypatch.setattr(dispatch, "GatewayDispatchService", _FakeDispatchService)
+
+    webhook = SimpleNamespace(id=uuid4(), description="desc", agent_id=agent_id)
+    board = SimpleNamespace(id=uuid4(), name="Board")
+    payload = SimpleNamespace(id=uuid4(), payload={"event": "test"})
+
+    await dispatch._notify_target_agent(
+        session=SimpleNamespace(),
+        board=board,
+        webhook=webhook,
+        payload=payload,
+    )
+
+    assert sent == [{"session_key": "mapped:session", "agent_name": "Mapped Agent"}]
+
+
+@pytest.mark.asyncio
+async def test_notify_target_agent_falls_back_to_lead(monkeypatch: pytest.MonkeyPatch) -> None:
+    lead_agent = SimpleNamespace(
+        id=uuid4(),
+        name="Lead Agent",
+        openclaw_session_id="lead:session",
+    )
+    sent: list[dict[str, str]] = []
+
+    class _FakeAgentObjects:
+        def filter_by(self, **kwargs: object) -> _FakeAgentObjects:
+            self._kwargs = kwargs
+            return self
+
+        async def first(self, session: object) -> object | None:
+            del session
+            if self._kwargs.get("is_board_lead") is True:
+                return lead_agent
+            return None
+
+    class _FakeDispatchService:
+        def __init__(self, session: object) -> None:
+            del session
+
+        async def optional_gateway_config_for_board(self, board: object) -> object:
+            del board
+            return object()
+
+        async def try_send_agent_message(
+            self,
+            *,
+            session_key: str,
+            config: object,
+            agent_name: str,
+            message: str,
+            deliver: bool = False,
+        ) -> None:
+            del config, message, deliver
+            sent.append({"session_key": session_key, "agent_name": agent_name})
+
+    monkeypatch.setattr(dispatch.Agent, "objects", _FakeAgentObjects())
+    monkeypatch.setattr(dispatch, "GatewayDispatchService", _FakeDispatchService)
+
+    webhook = SimpleNamespace(id=uuid4(), description="desc", agent_id=None)
+    board = SimpleNamespace(id=uuid4(), name="Board")
+    payload = SimpleNamespace(id=uuid4(), payload={"event": "test"})
+
+    await dispatch._notify_target_agent(
+        session=SimpleNamespace(),
+        board=board,
+        webhook=webhook,
+        payload=payload,
+    )
+
+    assert sent == [{"session_key": "lead:session", "agent_name": "Lead Agent"}]
+
+
 def test_dispatch_run_entrypoint_calls_async_flush(monkeypatch: pytest.MonkeyPatch) -> None:
     called: list[bool] = []
 

frontend/src/api/generated/agents/agents.ts

@@ -364,134 +364,6 @@ export const useCreateAgentApiV1AgentsPost = <
     queryClient,
   );
 };
-/**
- * Heartbeat an existing agent or create/provision one if needed.
- * @summary Heartbeat Or Create Agent
- */
-export type heartbeatOrCreateAgentApiV1AgentsHeartbeatPostResponse200 = {
-  data: AgentRead;
-  status: 200;
-};
-
-export type heartbeatOrCreateAgentApiV1AgentsHeartbeatPostResponse422 = {
-  data: HTTPValidationError;
-  status: 422;
-};
-
-export type heartbeatOrCreateAgentApiV1AgentsHeartbeatPostResponseSuccess =
-  heartbeatOrCreateAgentApiV1AgentsHeartbeatPostResponse200 & {
-    headers: Headers;
-  };
-export type heartbeatOrCreateAgentApiV1AgentsHeartbeatPostResponseError =
-  heartbeatOrCreateAgentApiV1AgentsHeartbeatPostResponse422 & {
-    headers: Headers;
-  };
-
-export type heartbeatOrCreateAgentApiV1AgentsHeartbeatPostResponse =
-  | heartbeatOrCreateAgentApiV1AgentsHeartbeatPostResponseSuccess
-  | heartbeatOrCreateAgentApiV1AgentsHeartbeatPostResponseError;
-
-export const getHeartbeatOrCreateAgentApiV1AgentsHeartbeatPostUrl = () => {
-  return `/api/v1/agents/heartbeat`;
-};
-
-export const heartbeatOrCreateAgentApiV1AgentsHeartbeatPost = async (
-  agentHeartbeatCreate: AgentHeartbeatCreate,
-  options?: RequestInit,
-): Promise<heartbeatOrCreateAgentApiV1AgentsHeartbeatPostResponse> => {
-  return customFetch<heartbeatOrCreateAgentApiV1AgentsHeartbeatPostResponse>(
-    getHeartbeatOrCreateAgentApiV1AgentsHeartbeatPostUrl(),
-    {
-      ...options,
-      method: "POST",
-      headers: { "Content-Type": "application/json", ...options?.headers },
-      body: JSON.stringify(agentHeartbeatCreate),
-    },
-  );
-};
-
-export const getHeartbeatOrCreateAgentApiV1AgentsHeartbeatPostMutationOptions =
-  <TError = HTTPValidationError, TContext = unknown>(options?: {
-    mutation?: UseMutationOptions<
-      Awaited<
-        ReturnType<typeof heartbeatOrCreateAgentApiV1AgentsHeartbeatPost>
-      >,
-      TError,
-      { data: AgentHeartbeatCreate },
-      TContext
-    >;
-    request?: SecondParameter<typeof customFetch>;
-  }): UseMutationOptions<
-    Awaited<ReturnType<typeof heartbeatOrCreateAgentApiV1AgentsHeartbeatPost>>,
-    TError,
-    { data: AgentHeartbeatCreate },
-    TContext
-  > => {
-    const mutationKey = ["heartbeatOrCreateAgentApiV1AgentsHeartbeatPost"];
-    const { mutation: mutationOptions, request: requestOptions } = options
-      ? options.mutation &&
-        "mutationKey" in options.mutation &&
-        options.mutation.mutationKey
-        ? options
-        : { ...options, mutation: { ...options.mutation, mutationKey } }
-      : { mutation: { mutationKey }, request: undefined };
-
-    const mutationFn: MutationFunction<
-      Awaited<
-        ReturnType<typeof heartbeatOrCreateAgentApiV1AgentsHeartbeatPost>
-      >,
-      { data: AgentHeartbeatCreate }
-    > = (props) => {
-      const { data } = props ?? {};
-
-      return heartbeatOrCreateAgentApiV1AgentsHeartbeatPost(
-        data,
-        requestOptions,
-      );
-    };
-
-    return { mutationFn, ...mutationOptions };
-  };
-
-export type HeartbeatOrCreateAgentApiV1AgentsHeartbeatPostMutationResult =
-  NonNullable<
-    Awaited<ReturnType<typeof heartbeatOrCreateAgentApiV1AgentsHeartbeatPost>>
-  >;
-export type HeartbeatOrCreateAgentApiV1AgentsHeartbeatPostMutationBody =
-  AgentHeartbeatCreate;
-export type HeartbeatOrCreateAgentApiV1AgentsHeartbeatPostMutationError =
-  HTTPValidationError;
-
-/**
- * @summary Heartbeat Or Create Agent
- */
-export const useHeartbeatOrCreateAgentApiV1AgentsHeartbeatPost = <
-  TError = HTTPValidationError,
-  TContext = unknown,
->(
-  options?: {
-    mutation?: UseMutationOptions<
-      Awaited<
-        ReturnType<typeof heartbeatOrCreateAgentApiV1AgentsHeartbeatPost>
-      >,
-      TError,
-      { data: AgentHeartbeatCreate },
-      TContext
-    >;
-    request?: SecondParameter<typeof customFetch>;
-  },
-  queryClient?: QueryClient,
-): UseMutationResult<
-  Awaited<ReturnType<typeof heartbeatOrCreateAgentApiV1AgentsHeartbeatPost>>,
-  TError,
-  { data: AgentHeartbeatCreate },
-  TContext
-> => {
-  return useMutation(
-    getHeartbeatOrCreateAgentApiV1AgentsHeartbeatPostMutationOptions(options),
-    queryClient,
-  );
-};
 /**
  * Stream agent updates as SSE events.
  * @summary Stream Agents
@@ -704,123 +576,6 @@ export function useStreamAgentsApiV1AgentsStreamGet<
   return { ...query, queryKey: queryOptions.queryKey };
 }
 
-/**
- * Delete an agent and clean related task state.
- * @summary Delete Agent
- */
-export type deleteAgentApiV1AgentsAgentIdDeleteResponse200 = {
-  data: OkResponse;
-  status: 200;
-};
-
-export type deleteAgentApiV1AgentsAgentIdDeleteResponse422 = {
-  data: HTTPValidationError;
-  status: 422;
-};
-
-export type deleteAgentApiV1AgentsAgentIdDeleteResponseSuccess =
-  deleteAgentApiV1AgentsAgentIdDeleteResponse200 & {
-    headers: Headers;
-  };
-export type deleteAgentApiV1AgentsAgentIdDeleteResponseError =
-  deleteAgentApiV1AgentsAgentIdDeleteResponse422 & {
-    headers: Headers;
-  };
-
-export type deleteAgentApiV1AgentsAgentIdDeleteResponse =
-  | deleteAgentApiV1AgentsAgentIdDeleteResponseSuccess
-  | deleteAgentApiV1AgentsAgentIdDeleteResponseError;
-
-export const getDeleteAgentApiV1AgentsAgentIdDeleteUrl = (agentId: string) => {
-  return `/api/v1/agents/${agentId}`;
-};
-
-export const deleteAgentApiV1AgentsAgentIdDelete = async (
-  agentId: string,
-  options?: RequestInit,
-): Promise<deleteAgentApiV1AgentsAgentIdDeleteResponse> => {
-  return customFetch<deleteAgentApiV1AgentsAgentIdDeleteResponse>(
-    getDeleteAgentApiV1AgentsAgentIdDeleteUrl(agentId),
-    {
-      ...options,
-      method: "DELETE",
-    },
-  );
-};
-
-export const getDeleteAgentApiV1AgentsAgentIdDeleteMutationOptions = <
-  TError = HTTPValidationError,
-  TContext = unknown,
->(options?: {
-  mutation?: UseMutationOptions<
-    Awaited<ReturnType<typeof deleteAgentApiV1AgentsAgentIdDelete>>,
-    TError,
-    { agentId: string },
-    TContext
-  >;
-  request?: SecondParameter<typeof customFetch>;
-}): UseMutationOptions<
-  Awaited<ReturnType<typeof deleteAgentApiV1AgentsAgentIdDelete>>,
-  TError,
-  { agentId: string },
-  TContext
-> => {
-  const mutationKey = ["deleteAgentApiV1AgentsAgentIdDelete"];
-  const { mutation: mutationOptions, request: requestOptions } = options
-    ? options.mutation &&
-      "mutationKey" in options.mutation &&
-      options.mutation.mutationKey
-      ? options
-      : { ...options, mutation: { ...options.mutation, mutationKey } }
-    : { mutation: { mutationKey }, request: undefined };
-
-  const mutationFn: MutationFunction<
-    Awaited<ReturnType<typeof deleteAgentApiV1AgentsAgentIdDelete>>,
-    { agentId: string }
-  > = (props) => {
-    const { agentId } = props ?? {};
-
-    return deleteAgentApiV1AgentsAgentIdDelete(agentId, requestOptions);
-  };
-
-  return { mutationFn, ...mutationOptions };
-};
-
-export type DeleteAgentApiV1AgentsAgentIdDeleteMutationResult = NonNullable<
-  Awaited<ReturnType<typeof deleteAgentApiV1AgentsAgentIdDelete>>
->;
-
-export type DeleteAgentApiV1AgentsAgentIdDeleteMutationError =
-  HTTPValidationError;
-
-/**
- * @summary Delete Agent
- */
-export const useDeleteAgentApiV1AgentsAgentIdDelete = <
-  TError = HTTPValidationError,
-  TContext = unknown,
->(
-  options?: {
-    mutation?: UseMutationOptions<
-      Awaited<ReturnType<typeof deleteAgentApiV1AgentsAgentIdDelete>>,
-      TError,
-      { agentId: string },
-      TContext
-    >;
-    request?: SecondParameter<typeof customFetch>;
-  },
-  queryClient?: QueryClient,
-): UseMutationResult<
-  Awaited<ReturnType<typeof deleteAgentApiV1AgentsAgentIdDelete>>,
-  TError,
-  { agentId: string },
-  TContext
-> => {
-  return useMutation(
-    getDeleteAgentApiV1AgentsAgentIdDeleteMutationOptions(options),
-    queryClient,
-  );
-};
 /**
  * Get a single agent by id.
  * @summary Get Agent
@@ -1182,6 +937,123 @@ export const useUpdateAgentApiV1AgentsAgentIdPatch = <
     queryClient,
   );
 };
+/**
+ * Delete an agent and clean related task state.
+ * @summary Delete Agent
+ */
+export type deleteAgentApiV1AgentsAgentIdDeleteResponse200 = {
+  data: OkResponse;
+  status: 200;
+};
+
+export type deleteAgentApiV1AgentsAgentIdDeleteResponse422 = {
+  data: HTTPValidationError;
+  status: 422;
+};
+
+export type deleteAgentApiV1AgentsAgentIdDeleteResponseSuccess =
+  deleteAgentApiV1AgentsAgentIdDeleteResponse200 & {
+    headers: Headers;
+  };
+export type deleteAgentApiV1AgentsAgentIdDeleteResponseError =
+  deleteAgentApiV1AgentsAgentIdDeleteResponse422 & {
+    headers: Headers;
+  };
+
+export type deleteAgentApiV1AgentsAgentIdDeleteResponse =
+  | deleteAgentApiV1AgentsAgentIdDeleteResponseSuccess
+  | deleteAgentApiV1AgentsAgentIdDeleteResponseError;
+
+export const getDeleteAgentApiV1AgentsAgentIdDeleteUrl = (agentId: string) => {
+  return `/api/v1/agents/${agentId}`;
+};
+
+export const deleteAgentApiV1AgentsAgentIdDelete = async (
+  agentId: string,
+  options?: RequestInit,
+): Promise<deleteAgentApiV1AgentsAgentIdDeleteResponse> => {
+  return customFetch<deleteAgentApiV1AgentsAgentIdDeleteResponse>(
+    getDeleteAgentApiV1AgentsAgentIdDeleteUrl(agentId),
+    {
+      ...options,
+      method: "DELETE",
+    },
+  );
+};
+
+export const getDeleteAgentApiV1AgentsAgentIdDeleteMutationOptions = <
+  TError = HTTPValidationError,
+  TContext = unknown,
+>(options?: {
+  mutation?: UseMutationOptions<
+    Awaited<ReturnType<typeof deleteAgentApiV1AgentsAgentIdDelete>>,
+    TError,
+    { agentId: string },
+    TContext
+  >;
+  request?: SecondParameter<typeof customFetch>;
+}): UseMutationOptions<
+  Awaited<ReturnType<typeof deleteAgentApiV1AgentsAgentIdDelete>>,
+  TError,
+  { agentId: string },
+  TContext
+> => {
+  const mutationKey = ["deleteAgentApiV1AgentsAgentIdDelete"];
+  const { mutation: mutationOptions, request: requestOptions } = options
+    ? options.mutation &&
+      "mutationKey" in options.mutation &&
+      options.mutation.mutationKey
+      ? options
+      : { ...options, mutation: { ...options.mutation, mutationKey } }
+    : { mutation: { mutationKey }, request: undefined };
+
+  const mutationFn: MutationFunction<
+    Awaited<ReturnType<typeof deleteAgentApiV1AgentsAgentIdDelete>>,
+    { agentId: string }
+  > = (props) => {
+    const { agentId } = props ?? {};
+
+    return deleteAgentApiV1AgentsAgentIdDelete(agentId, requestOptions);
+  };
+
+  return { mutationFn, ...mutationOptions };
+};
+
+export type DeleteAgentApiV1AgentsAgentIdDeleteMutationResult = NonNullable<
+  Awaited<ReturnType<typeof deleteAgentApiV1AgentsAgentIdDelete>>
+>;
+
+export type DeleteAgentApiV1AgentsAgentIdDeleteMutationError =
+  HTTPValidationError;
+
+/**
+ * @summary Delete Agent
+ */
+export const useDeleteAgentApiV1AgentsAgentIdDelete = <
+  TError = HTTPValidationError,
+  TContext = unknown,
+>(
+  options?: {
+    mutation?: UseMutationOptions<
+      Awaited<ReturnType<typeof deleteAgentApiV1AgentsAgentIdDelete>>,
+      TError,
+      { agentId: string },
+      TContext
+    >;
+    request?: SecondParameter<typeof customFetch>;
+  },
+  queryClient?: QueryClient,
+): UseMutationResult<
+  Awaited<ReturnType<typeof deleteAgentApiV1AgentsAgentIdDelete>>,
+  TError,
+  { agentId: string },
+  TContext
+> => {
+  return useMutation(
+    getDeleteAgentApiV1AgentsAgentIdDeleteMutationOptions(options),
+    queryClient,
+  );
+};
 /**
  * Record a heartbeat for a specific agent.
  * @summary Heartbeat Agent
@@ -1310,3 +1182,131 @@ export const useHeartbeatAgentApiV1AgentsAgentIdHeartbeatPost = <
     queryClient,
   );
 };
+/**
+ * Heartbeat an existing agent or create/provision one if needed.
+ * @summary Heartbeat Or Create Agent
+ */
+export type heartbeatOrCreateAgentApiV1AgentsHeartbeatPostResponse200 = {
+  data: AgentRead;
+  status: 200;
+};
+
+export type heartbeatOrCreateAgentApiV1AgentsHeartbeatPostResponse422 = {
+  data: HTTPValidationError;
+  status: 422;
+};
+
+export type heartbeatOrCreateAgentApiV1AgentsHeartbeatPostResponseSuccess =
+  heartbeatOrCreateAgentApiV1AgentsHeartbeatPostResponse200 & {
+    headers: Headers;
+  };
+export type heartbeatOrCreateAgentApiV1AgentsHeartbeatPostResponseError =
+  heartbeatOrCreateAgentApiV1AgentsHeartbeatPostResponse422 & {
+    headers: Headers;
+  };
+
+export type heartbeatOrCreateAgentApiV1AgentsHeartbeatPostResponse =
+  | heartbeatOrCreateAgentApiV1AgentsHeartbeatPostResponseSuccess
+  | heartbeatOrCreateAgentApiV1AgentsHeartbeatPostResponseError;
+
+export const getHeartbeatOrCreateAgentApiV1AgentsHeartbeatPostUrl = () => {
+  return `/api/v1/agents/heartbeat`;
+};
+
+export const heartbeatOrCreateAgentApiV1AgentsHeartbeatPost = async (
+  agentHeartbeatCreate: AgentHeartbeatCreate,
+  options?: RequestInit,
+): Promise<heartbeatOrCreateAgentApiV1AgentsHeartbeatPostResponse> => {
+  return customFetch<heartbeatOrCreateAgentApiV1AgentsHeartbeatPostResponse>(
+    getHeartbeatOrCreateAgentApiV1AgentsHeartbeatPostUrl(),
+    {
+      ...options,
+      method: "POST",
+      headers: { "Content-Type": "application/json", ...options?.headers },
+      body: JSON.stringify(agentHeartbeatCreate),
+    },
+  );
+};
+
+export const getHeartbeatOrCreateAgentApiV1AgentsHeartbeatPostMutationOptions =
+  <TError = HTTPValidationError, TContext = unknown>(options?: {
+    mutation?: UseMutationOptions<
+      Awaited<
+        ReturnType<typeof heartbeatOrCreateAgentApiV1AgentsHeartbeatPost>
+      >,
+      TError,
+      { data: AgentHeartbeatCreate },
+      TContext
+    >;
+    request?: SecondParameter<typeof customFetch>;
+  }): UseMutationOptions<
+    Awaited<ReturnType<typeof heartbeatOrCreateAgentApiV1AgentsHeartbeatPost>>,
+    TError,
+    { data: AgentHeartbeatCreate },
+    TContext
+  > => {
+    const mutationKey = ["heartbeatOrCreateAgentApiV1AgentsHeartbeatPost"];
+    const { mutation: mutationOptions, request: requestOptions } = options
+      ? options.mutation &&
+        "mutationKey" in options.mutation &&
+        options.mutation.mutationKey
+        ? options
+        : { ...options, mutation: { ...options.mutation, mutationKey } }
+      : { mutation: { mutationKey }, request: undefined };
+
+    const mutationFn: MutationFunction<
+      Awaited<
+        ReturnType<typeof heartbeatOrCreateAgentApiV1AgentsHeartbeatPost>
+      >,
+      { data: AgentHeartbeatCreate }
+    > = (props) => {
+      const { data } = props ?? {};
+
+      return heartbeatOrCreateAgentApiV1AgentsHeartbeatPost(
+        data,
+        requestOptions,
+      );
+    };
+
+    return { mutationFn, ...mutationOptions };
+  };
+
+export type HeartbeatOrCreateAgentApiV1AgentsHeartbeatPostMutationResult =
+  NonNullable<
+    Awaited<ReturnType<typeof heartbeatOrCreateAgentApiV1AgentsHeartbeatPost>>
+  >;
+export type HeartbeatOrCreateAgentApiV1AgentsHeartbeatPostMutationBody =
+  AgentHeartbeatCreate;
+export type HeartbeatOrCreateAgentApiV1AgentsHeartbeatPostMutationError =
+  HTTPValidationError;
+
+/**
+ * @summary Heartbeat Or Create Agent
+ */
+export const useHeartbeatOrCreateAgentApiV1AgentsHeartbeatPost = <
+  TError = HTTPValidationError,
+  TContext = unknown,
+>(
+  options?: {
+    mutation?: UseMutationOptions<
+      Awaited<
+        ReturnType<typeof heartbeatOrCreateAgentApiV1AgentsHeartbeatPost>
+      >,
+      TError,
+      { data: AgentHeartbeatCreate },
+      TContext
+    >;
+    request?: SecondParameter<typeof customFetch>;
+  },
+  queryClient?: QueryClient,
+): UseMutationResult<
+  Awaited<ReturnType<typeof heartbeatOrCreateAgentApiV1AgentsHeartbeatPost>>,
+  TError,
+  { data: AgentHeartbeatCreate },
+  TContext
+> => {
+  return useMutation(
+    getHeartbeatOrCreateAgentApiV1AgentsHeartbeatPostMutationOptions(options),
+    queryClient,
+  );
+};

frontend/src/api/generated/auth/auth.ts

@@ -12,27 +12,38 @@ import type {
   UseMutationResult,
 } from "@tanstack/react-query";
 
-import type { UserRead } from ".././model";
+import type { LLMErrorResponse, UserRead } from ".././model";
 
 import { customFetch } from "../../mutator";
 
 type SecondParameter<T extends (...args: never) => unknown> = Parameters<T>[1];
 
 /**
- * Return the authenticated user profile from token claims.
+ * Resolve caller identity from auth headers and return the canonical user profile. This endpoint does not accept a request body.
- * @summary Bootstrap User
+ * @summary Bootstrap Authenticated User Context
  */
 export type bootstrapUserApiV1AuthBootstrapPostResponse200 = {
   data: UserRead;
   status: 200;
 };
 
+export type bootstrapUserApiV1AuthBootstrapPostResponse401 = {
+  data: LLMErrorResponse;
+  status: 401;
+};
+
 export type bootstrapUserApiV1AuthBootstrapPostResponseSuccess =
   bootstrapUserApiV1AuthBootstrapPostResponse200 & {
     headers: Headers;
   };
+export type bootstrapUserApiV1AuthBootstrapPostResponseError =
+  bootstrapUserApiV1AuthBootstrapPostResponse401 & {
+    headers: Headers;
+  };
+
 export type bootstrapUserApiV1AuthBootstrapPostResponse =
-  bootstrapUserApiV1AuthBootstrapPostResponseSuccess;
+  | bootstrapUserApiV1AuthBootstrapPostResponseSuccess
+  | bootstrapUserApiV1AuthBootstrapPostResponseError;
 
 export const getBootstrapUserApiV1AuthBootstrapPostUrl = () => {
   return `/api/v1/auth/bootstrap`;
@@ -51,7 +62,7 @@ export const bootstrapUserApiV1AuthBootstrapPost = async (
 };
 
 export const getBootstrapUserApiV1AuthBootstrapPostMutationOptions = <
-  TError = unknown,
+  TError = LLMErrorResponse,
   TContext = unknown,
 >(options?: {
   mutation?: UseMutationOptions<
@@ -90,13 +101,13 @@ export type BootstrapUserApiV1AuthBootstrapPostMutationResult = NonNullable<
   Awaited<ReturnType<typeof bootstrapUserApiV1AuthBootstrapPost>>
 >;
 
-export type BootstrapUserApiV1AuthBootstrapPostMutationError = unknown;
+export type BootstrapUserApiV1AuthBootstrapPostMutationError = LLMErrorResponse;
 
 /**
- * @summary Bootstrap User
+ * @summary Bootstrap Authenticated User Context
  */
 export const useBootstrapUserApiV1AuthBootstrapPost = <
-  TError = unknown,
+  TError = LLMErrorResponse,
   TContext = unknown,
 >(
   options?: {

frontend/src/api/generated/board-groups/board-groups.ts

@@ -369,129 +369,6 @@ export const useCreateBoardGroupApiV1BoardGroupsPost = <
     queryClient,
   );
 };
-/**
- * Delete a board group.
- * @summary Delete Board Group
- */
-export type deleteBoardGroupApiV1BoardGroupsGroupIdDeleteResponse200 = {
-  data: OkResponse;
-  status: 200;
-};
-
-export type deleteBoardGroupApiV1BoardGroupsGroupIdDeleteResponse422 = {
-  data: HTTPValidationError;
-  status: 422;
-};
-
-export type deleteBoardGroupApiV1BoardGroupsGroupIdDeleteResponseSuccess =
-  deleteBoardGroupApiV1BoardGroupsGroupIdDeleteResponse200 & {
-    headers: Headers;
-  };
-export type deleteBoardGroupApiV1BoardGroupsGroupIdDeleteResponseError =
-  deleteBoardGroupApiV1BoardGroupsGroupIdDeleteResponse422 & {
-    headers: Headers;
-  };
-
-export type deleteBoardGroupApiV1BoardGroupsGroupIdDeleteResponse =
-  | deleteBoardGroupApiV1BoardGroupsGroupIdDeleteResponseSuccess
-  | deleteBoardGroupApiV1BoardGroupsGroupIdDeleteResponseError;
-
-export const getDeleteBoardGroupApiV1BoardGroupsGroupIdDeleteUrl = (
-  groupId: string,
-) => {
-  return `/api/v1/board-groups/${groupId}`;
-};
-
-export const deleteBoardGroupApiV1BoardGroupsGroupIdDelete = async (
-  groupId: string,
-  options?: RequestInit,
-): Promise<deleteBoardGroupApiV1BoardGroupsGroupIdDeleteResponse> => {
-  return customFetch<deleteBoardGroupApiV1BoardGroupsGroupIdDeleteResponse>(
-    getDeleteBoardGroupApiV1BoardGroupsGroupIdDeleteUrl(groupId),
-    {
-      ...options,
-      method: "DELETE",
-    },
-  );
-};
-
-export const getDeleteBoardGroupApiV1BoardGroupsGroupIdDeleteMutationOptions = <
-  TError = HTTPValidationError,
-  TContext = unknown,
->(options?: {
-  mutation?: UseMutationOptions<
-    Awaited<ReturnType<typeof deleteBoardGroupApiV1BoardGroupsGroupIdDelete>>,
-    TError,
-    { groupId: string },
-    TContext
-  >;
-  request?: SecondParameter<typeof customFetch>;
-}): UseMutationOptions<
-  Awaited<ReturnType<typeof deleteBoardGroupApiV1BoardGroupsGroupIdDelete>>,
-  TError,
-  { groupId: string },
-  TContext
-> => {
-  const mutationKey = ["deleteBoardGroupApiV1BoardGroupsGroupIdDelete"];
-  const { mutation: mutationOptions, request: requestOptions } = options
-    ? options.mutation &&
-      "mutationKey" in options.mutation &&
-      options.mutation.mutationKey
-      ? options
-      : { ...options, mutation: { ...options.mutation, mutationKey } }
-    : { mutation: { mutationKey }, request: undefined };
-
-  const mutationFn: MutationFunction<
-    Awaited<ReturnType<typeof deleteBoardGroupApiV1BoardGroupsGroupIdDelete>>,
-    { groupId: string }
-  > = (props) => {
-    const { groupId } = props ?? {};
-
-    return deleteBoardGroupApiV1BoardGroupsGroupIdDelete(
-      groupId,
-      requestOptions,
-    );
-  };
-
-  return { mutationFn, ...mutationOptions };
-};
-
-export type DeleteBoardGroupApiV1BoardGroupsGroupIdDeleteMutationResult =
-  NonNullable<
-    Awaited<ReturnType<typeof deleteBoardGroupApiV1BoardGroupsGroupIdDelete>>
-  >;
-
-export type DeleteBoardGroupApiV1BoardGroupsGroupIdDeleteMutationError =
-  HTTPValidationError;
-
-/**
- * @summary Delete Board Group
- */
-export const useDeleteBoardGroupApiV1BoardGroupsGroupIdDelete = <
-  TError = HTTPValidationError,
-  TContext = unknown,
->(
-  options?: {
-    mutation?: UseMutationOptions<
-      Awaited<ReturnType<typeof deleteBoardGroupApiV1BoardGroupsGroupIdDelete>>,
-      TError,
-      { groupId: string },
-      TContext
-    >;
-    request?: SecondParameter<typeof customFetch>;
-  },
-  queryClient?: QueryClient,
-): UseMutationResult<
-  Awaited<ReturnType<typeof deleteBoardGroupApiV1BoardGroupsGroupIdDelete>>,
-  TError,
-  { groupId: string },
-  TContext
-> => {
-  return useMutation(
-    getDeleteBoardGroupApiV1BoardGroupsGroupIdDeleteMutationOptions(options),
-    queryClient,
-  );
-};
 /**
  * Get a board group by id.
  * @summary Get Board Group
@@ -830,161 +707,125 @@ export const useUpdateBoardGroupApiV1BoardGroupsGroupIdPatch = <
   );
 };
 /**
- * Apply heartbeat settings to agents in a board group.
+ * Delete a board group.
- * @summary Apply Board Group Heartbeat
+ * @summary Delete Board Group
  */
-export type applyBoardGroupHeartbeatApiV1BoardGroupsGroupIdHeartbeatPostResponse200 =
+export type deleteBoardGroupApiV1BoardGroupsGroupIdDeleteResponse200 = {
-  {
+  data: OkResponse;
-    data: BoardGroupHeartbeatApplyResult;
+  status: 200;
-    status: 200;
+};
-  };
 
-export type applyBoardGroupHeartbeatApiV1BoardGroupsGroupIdHeartbeatPostResponse422 =
+export type deleteBoardGroupApiV1BoardGroupsGroupIdDeleteResponse422 = {
-  {
+  data: HTTPValidationError;
-    data: HTTPValidationError;
+  status: 422;
-    status: 422;
+};
-  };
 
-export type applyBoardGroupHeartbeatApiV1BoardGroupsGroupIdHeartbeatPostResponseSuccess =
+export type deleteBoardGroupApiV1BoardGroupsGroupIdDeleteResponseSuccess =
-  applyBoardGroupHeartbeatApiV1BoardGroupsGroupIdHeartbeatPostResponse200 & {
+  deleteBoardGroupApiV1BoardGroupsGroupIdDeleteResponse200 & {
     headers: Headers;
   };
-export type applyBoardGroupHeartbeatApiV1BoardGroupsGroupIdHeartbeatPostResponseError =
+export type deleteBoardGroupApiV1BoardGroupsGroupIdDeleteResponseError =
-  applyBoardGroupHeartbeatApiV1BoardGroupsGroupIdHeartbeatPostResponse422 & {
+  deleteBoardGroupApiV1BoardGroupsGroupIdDeleteResponse422 & {
     headers: Headers;
   };
 
-export type applyBoardGroupHeartbeatApiV1BoardGroupsGroupIdHeartbeatPostResponse =
+export type deleteBoardGroupApiV1BoardGroupsGroupIdDeleteResponse =
+  | deleteBoardGroupApiV1BoardGroupsGroupIdDeleteResponseSuccess
+  | deleteBoardGroupApiV1BoardGroupsGroupIdDeleteResponseError;
 
-    | applyBoardGroupHeartbeatApiV1BoardGroupsGroupIdHeartbeatPostResponseSuccess
+export const getDeleteBoardGroupApiV1BoardGroupsGroupIdDeleteUrl = (
-    | applyBoardGroupHeartbeatApiV1BoardGroupsGroupIdHeartbeatPostResponseError;
+  groupId: string,
+) => {
+  return `/api/v1/board-groups/${groupId}`;
+};
 
-export const getApplyBoardGroupHeartbeatApiV1BoardGroupsGroupIdHeartbeatPostUrl =
+export const deleteBoardGroupApiV1BoardGroupsGroupIdDelete = async (
-  (groupId: string) => {
+  groupId: string,
-    return `/api/v1/board-groups/${groupId}/heartbeat`;
+  options?: RequestInit,
-  };
+): Promise<deleteBoardGroupApiV1BoardGroupsGroupIdDeleteResponse> => {
+  return customFetch<deleteBoardGroupApiV1BoardGroupsGroupIdDeleteResponse>(
+    getDeleteBoardGroupApiV1BoardGroupsGroupIdDeleteUrl(groupId),
+    {
+      ...options,
+      method: "DELETE",
+    },
+  );
+};
 
-export const applyBoardGroupHeartbeatApiV1BoardGroupsGroupIdHeartbeatPost =
+export const getDeleteBoardGroupApiV1BoardGroupsGroupIdDeleteMutationOptions = <
-  async (
+  TError = HTTPValidationError,
-    groupId: string,
+  TContext = unknown,
-    boardGroupHeartbeatApply: BoardGroupHeartbeatApply,
+>(options?: {
-    options?: RequestInit,
+  mutation?: UseMutationOptions<
-  ): Promise<applyBoardGroupHeartbeatApiV1BoardGroupsGroupIdHeartbeatPostResponse> => {
+    Awaited<ReturnType<typeof deleteBoardGroupApiV1BoardGroupsGroupIdDelete>>,
-    return customFetch<applyBoardGroupHeartbeatApiV1BoardGroupsGroupIdHeartbeatPostResponse>(
+    TError,
-      getApplyBoardGroupHeartbeatApiV1BoardGroupsGroupIdHeartbeatPostUrl(
+    { groupId: string },
-        groupId,
+    TContext
-      ),
+  >;
-      {
+  request?: SecondParameter<typeof customFetch>;
-        ...options,
+}): UseMutationOptions<
-        method: "POST",
+  Awaited<ReturnType<typeof deleteBoardGroupApiV1BoardGroupsGroupIdDelete>>,
-        headers: { "Content-Type": "application/json", ...options?.headers },
+  TError,
-        body: JSON.stringify(boardGroupHeartbeatApply),
+  { groupId: string },
-      },
+  TContext
+> => {
+  const mutationKey = ["deleteBoardGroupApiV1BoardGroupsGroupIdDelete"];
+  const { mutation: mutationOptions, request: requestOptions } = options
+    ? options.mutation &&
+      "mutationKey" in options.mutation &&
+      options.mutation.mutationKey
+      ? options
+      : { ...options, mutation: { ...options.mutation, mutationKey } }
+    : { mutation: { mutationKey }, request: undefined };
+
+  const mutationFn: MutationFunction<
+    Awaited<ReturnType<typeof deleteBoardGroupApiV1BoardGroupsGroupIdDelete>>,
+    { groupId: string }
+  > = (props) => {
+    const { groupId } = props ?? {};
+
+    return deleteBoardGroupApiV1BoardGroupsGroupIdDelete(
+      groupId,
+      requestOptions,
     );
   };
 
-export const getApplyBoardGroupHeartbeatApiV1BoardGroupsGroupIdHeartbeatPostMutationOptions =
+  return { mutationFn, ...mutationOptions };
-  <TError = HTTPValidationError, TContext = unknown>(options?: {
+};
-    mutation?: UseMutationOptions<
-      Awaited<
-        ReturnType<
-          typeof applyBoardGroupHeartbeatApiV1BoardGroupsGroupIdHeartbeatPost
-        >
-      >,
-      TError,
-      { groupId: string; data: BoardGroupHeartbeatApply },
-      TContext
-    >;
-    request?: SecondParameter<typeof customFetch>;
-  }): UseMutationOptions<
-    Awaited<
-      ReturnType<
-        typeof applyBoardGroupHeartbeatApiV1BoardGroupsGroupIdHeartbeatPost
-      >
-    >,
-    TError,
-    { groupId: string; data: BoardGroupHeartbeatApply },
-    TContext
-  > => {
-    const mutationKey = [
-      "applyBoardGroupHeartbeatApiV1BoardGroupsGroupIdHeartbeatPost",
-    ];
-    const { mutation: mutationOptions, request: requestOptions } = options
-      ? options.mutation &&
-        "mutationKey" in options.mutation &&
-        options.mutation.mutationKey
-        ? options
-        : { ...options, mutation: { ...options.mutation, mutationKey } }
-      : { mutation: { mutationKey }, request: undefined };
 
-    const mutationFn: MutationFunction<
+export type DeleteBoardGroupApiV1BoardGroupsGroupIdDeleteMutationResult =
-      Awaited<
-        ReturnType<
-          typeof applyBoardGroupHeartbeatApiV1BoardGroupsGroupIdHeartbeatPost
-        >
-      >,
-      { groupId: string; data: BoardGroupHeartbeatApply }
-    > = (props) => {
-      const { groupId, data } = props ?? {};
-
-      return applyBoardGroupHeartbeatApiV1BoardGroupsGroupIdHeartbeatPost(
-        groupId,
-        data,
-        requestOptions,
-      );
-    };
-
-    return { mutationFn, ...mutationOptions };
-  };
-
-export type ApplyBoardGroupHeartbeatApiV1BoardGroupsGroupIdHeartbeatPostMutationResult =
   NonNullable<
-    Awaited<
+    Awaited<ReturnType<typeof deleteBoardGroupApiV1BoardGroupsGroupIdDelete>>
-      ReturnType<
-        typeof applyBoardGroupHeartbeatApiV1BoardGroupsGroupIdHeartbeatPost
-      >
-    >
   >;
-export type ApplyBoardGroupHeartbeatApiV1BoardGroupsGroupIdHeartbeatPostMutationBody =
+
-  BoardGroupHeartbeatApply;
+export type DeleteBoardGroupApiV1BoardGroupsGroupIdDeleteMutationError =
-export type ApplyBoardGroupHeartbeatApiV1BoardGroupsGroupIdHeartbeatPostMutationError =
   HTTPValidationError;
 
 /**
- * @summary Apply Board Group Heartbeat
+ * @summary Delete Board Group
  */
-export const useApplyBoardGroupHeartbeatApiV1BoardGroupsGroupIdHeartbeatPost = <
+export const useDeleteBoardGroupApiV1BoardGroupsGroupIdDelete = <
   TError = HTTPValidationError,
   TContext = unknown,
 >(
   options?: {
     mutation?: UseMutationOptions<
-      Awaited<
+      Awaited<ReturnType<typeof deleteBoardGroupApiV1BoardGroupsGroupIdDelete>>,
-        ReturnType<
-          typeof applyBoardGroupHeartbeatApiV1BoardGroupsGroupIdHeartbeatPost
-        >
-      >,
       TError,
-      { groupId: string; data: BoardGroupHeartbeatApply },
+      { groupId: string },
       TContext
     >;
     request?: SecondParameter<typeof customFetch>;
   },
   queryClient?: QueryClient,
 ): UseMutationResult<
-  Awaited<
+  Awaited<ReturnType<typeof deleteBoardGroupApiV1BoardGroupsGroupIdDelete>>,
-    ReturnType<
-      typeof applyBoardGroupHeartbeatApiV1BoardGroupsGroupIdHeartbeatPost
-    >
-  >,
   TError,
-  { groupId: string; data: BoardGroupHeartbeatApply },
+  { groupId: string },
   TContext
 > => {
   return useMutation(
-    getApplyBoardGroupHeartbeatApiV1BoardGroupsGroupIdHeartbeatPostMutationOptions(
+    getDeleteBoardGroupApiV1BoardGroupsGroupIdDeleteMutationOptions(options),
-      options,
-    ),
     queryClient,
   );
 };
@@ -1290,3 +1131,163 @@ export function useGetBoardGroupSnapshotApiV1BoardGroupsGroupIdSnapshotGet<
 
   return { ...query, queryKey: queryOptions.queryKey };
 }
+
+/**
+ * Apply heartbeat settings to agents in a board group.
+ * @summary Apply Board Group Heartbeat
+ */
+export type applyBoardGroupHeartbeatApiV1BoardGroupsGroupIdHeartbeatPostResponse200 =
+  {
+    data: BoardGroupHeartbeatApplyResult;
+    status: 200;
+  };
+
+export type applyBoardGroupHeartbeatApiV1BoardGroupsGroupIdHeartbeatPostResponse422 =
+  {
+    data: HTTPValidationError;
+    status: 422;
+  };
+
+export type applyBoardGroupHeartbeatApiV1BoardGroupsGroupIdHeartbeatPostResponseSuccess =
+  applyBoardGroupHeartbeatApiV1BoardGroupsGroupIdHeartbeatPostResponse200 & {
+    headers: Headers;
+  };
+export type applyBoardGroupHeartbeatApiV1BoardGroupsGroupIdHeartbeatPostResponseError =
+  applyBoardGroupHeartbeatApiV1BoardGroupsGroupIdHeartbeatPostResponse422 & {
+    headers: Headers;
+  };
+
+export type applyBoardGroupHeartbeatApiV1BoardGroupsGroupIdHeartbeatPostResponse =
+
+    | applyBoardGroupHeartbeatApiV1BoardGroupsGroupIdHeartbeatPostResponseSuccess
+    | applyBoardGroupHeartbeatApiV1BoardGroupsGroupIdHeartbeatPostResponseError;
+
+export const getApplyBoardGroupHeartbeatApiV1BoardGroupsGroupIdHeartbeatPostUrl =
+  (groupId: string) => {
+    return `/api/v1/board-groups/${groupId}/heartbeat`;
+  };
+
+export const applyBoardGroupHeartbeatApiV1BoardGroupsGroupIdHeartbeatPost =
+  async (
+    groupId: string,
+    boardGroupHeartbeatApply: BoardGroupHeartbeatApply,
+    options?: RequestInit,
+  ): Promise<applyBoardGroupHeartbeatApiV1BoardGroupsGroupIdHeartbeatPostResponse> => {
+    return customFetch<applyBoardGroupHeartbeatApiV1BoardGroupsGroupIdHeartbeatPostResponse>(
+      getApplyBoardGroupHeartbeatApiV1BoardGroupsGroupIdHeartbeatPostUrl(
+        groupId,
+      ),
+      {
+        ...options,
+        method: "POST",
+        headers: { "Content-Type": "application/json", ...options?.headers },
+        body: JSON.stringify(boardGroupHeartbeatApply),
+      },
+    );
+  };
+
+export const getApplyBoardGroupHeartbeatApiV1BoardGroupsGroupIdHeartbeatPostMutationOptions =
+  <TError = HTTPValidationError, TContext = unknown>(options?: {
+    mutation?: UseMutationOptions<
+      Awaited<
+        ReturnType<
+          typeof applyBoardGroupHeartbeatApiV1BoardGroupsGroupIdHeartbeatPost
+        >
+      >,
+      TError,
+      { groupId: string; data: BoardGroupHeartbeatApply },
+      TContext
+    >;
+    request?: SecondParameter<typeof customFetch>;
+  }): UseMutationOptions<
+    Awaited<
+      ReturnType<
+        typeof applyBoardGroupHeartbeatApiV1BoardGroupsGroupIdHeartbeatPost
+      >
+    >,
+    TError,
+    { groupId: string; data: BoardGroupHeartbeatApply },
+    TContext
+  > => {
+    const mutationKey = [
+      "applyBoardGroupHeartbeatApiV1BoardGroupsGroupIdHeartbeatPost",
+    ];
+    const { mutation: mutationOptions, request: requestOptions } = options
+      ? options.mutation &&
+        "mutationKey" in options.mutation &&
+        options.mutation.mutationKey
+        ? options
+        : { ...options, mutation: { ...options.mutation, mutationKey } }
+      : { mutation: { mutationKey }, request: undefined };
+
+    const mutationFn: MutationFunction<
+      Awaited<
+        ReturnType<
+          typeof applyBoardGroupHeartbeatApiV1BoardGroupsGroupIdHeartbeatPost
+        >
+      >,
+      { groupId: string; data: BoardGroupHeartbeatApply }
+    > = (props) => {
+      const { groupId, data } = props ?? {};
+
+      return applyBoardGroupHeartbeatApiV1BoardGroupsGroupIdHeartbeatPost(
+        groupId,
+        data,
+        requestOptions,
+      );
+    };
+
+    return { mutationFn, ...mutationOptions };
+  };
+
+export type ApplyBoardGroupHeartbeatApiV1BoardGroupsGroupIdHeartbeatPostMutationResult =
+  NonNullable<
+    Awaited<
+      ReturnType<
+        typeof applyBoardGroupHeartbeatApiV1BoardGroupsGroupIdHeartbeatPost
+      >
+    >
+  >;
+export type ApplyBoardGroupHeartbeatApiV1BoardGroupsGroupIdHeartbeatPostMutationBody =
+  BoardGroupHeartbeatApply;
+export type ApplyBoardGroupHeartbeatApiV1BoardGroupsGroupIdHeartbeatPostMutationError =
+  HTTPValidationError;
+
+/**
+ * @summary Apply Board Group Heartbeat
+ */
+export const useApplyBoardGroupHeartbeatApiV1BoardGroupsGroupIdHeartbeatPost = <
+  TError = HTTPValidationError,
+  TContext = unknown,
+>(
+  options?: {
+    mutation?: UseMutationOptions<
+      Awaited<
+        ReturnType<
+          typeof applyBoardGroupHeartbeatApiV1BoardGroupsGroupIdHeartbeatPost
+        >
+      >,
+      TError,
+      { groupId: string; data: BoardGroupHeartbeatApply },
+      TContext
+    >;
+    request?: SecondParameter<typeof customFetch>;
+  },
+  queryClient?: QueryClient,
+): UseMutationResult<
+  Awaited<
+    ReturnType<
+      typeof applyBoardGroupHeartbeatApiV1BoardGroupsGroupIdHeartbeatPost
+    >
+  >,
+  TError,
+  { groupId: string; data: BoardGroupHeartbeatApply },
+  TContext
+> => {
+  return useMutation(
+    getApplyBoardGroupHeartbeatApiV1BoardGroupsGroupIdHeartbeatPostMutationOptions(
+      options,
+    ),
+    queryClient,
+  );
+};

frontend/src/api/generated/board-onboarding/board-onboarding.ts

@@ -274,6 +274,298 @@ export function useGetOnboardingApiV1BoardsBoardIdOnboardingGet<
   return { ...query, queryKey: queryOptions.queryKey };
 }
 
+/**
+ * Start onboarding and send instructions to the gateway agent.
+ * @summary Start Onboarding
+ */
+export type startOnboardingApiV1BoardsBoardIdOnboardingStartPostResponse200 = {
+  data: BoardOnboardingRead;
+  status: 200;
+};
+
+export type startOnboardingApiV1BoardsBoardIdOnboardingStartPostResponse422 = {
+  data: HTTPValidationError;
+  status: 422;
+};
+
+export type startOnboardingApiV1BoardsBoardIdOnboardingStartPostResponseSuccess =
+  startOnboardingApiV1BoardsBoardIdOnboardingStartPostResponse200 & {
+    headers: Headers;
+  };
+export type startOnboardingApiV1BoardsBoardIdOnboardingStartPostResponseError =
+  startOnboardingApiV1BoardsBoardIdOnboardingStartPostResponse422 & {
+    headers: Headers;
+  };
+
+export type startOnboardingApiV1BoardsBoardIdOnboardingStartPostResponse =
+  | startOnboardingApiV1BoardsBoardIdOnboardingStartPostResponseSuccess
+  | startOnboardingApiV1BoardsBoardIdOnboardingStartPostResponseError;
+
+export const getStartOnboardingApiV1BoardsBoardIdOnboardingStartPostUrl = (
+  boardId: string,
+) => {
+  return `/api/v1/boards/${boardId}/onboarding/start`;
+};
+
+export const startOnboardingApiV1BoardsBoardIdOnboardingStartPost = async (
+  boardId: string,
+  boardOnboardingStart: BoardOnboardingStart,
+  options?: RequestInit,
+): Promise<startOnboardingApiV1BoardsBoardIdOnboardingStartPostResponse> => {
+  return customFetch<startOnboardingApiV1BoardsBoardIdOnboardingStartPostResponse>(
+    getStartOnboardingApiV1BoardsBoardIdOnboardingStartPostUrl(boardId),
+    {
+      ...options,
+      method: "POST",
+      headers: { "Content-Type": "application/json", ...options?.headers },
+      body: JSON.stringify(boardOnboardingStart),
+    },
+  );
+};
+
+export const getStartOnboardingApiV1BoardsBoardIdOnboardingStartPostMutationOptions =
+  <TError = HTTPValidationError, TContext = unknown>(options?: {
+    mutation?: UseMutationOptions<
+      Awaited<
+        ReturnType<typeof startOnboardingApiV1BoardsBoardIdOnboardingStartPost>
+      >,
+      TError,
+      { boardId: string; data: BoardOnboardingStart },
+      TContext
+    >;
+    request?: SecondParameter<typeof customFetch>;
+  }): UseMutationOptions<
+    Awaited<
+      ReturnType<typeof startOnboardingApiV1BoardsBoardIdOnboardingStartPost>
+    >,
+    TError,
+    { boardId: string; data: BoardOnboardingStart },
+    TContext
+  > => {
+    const mutationKey = [
+      "startOnboardingApiV1BoardsBoardIdOnboardingStartPost",
+    ];
+    const { mutation: mutationOptions, request: requestOptions } = options
+      ? options.mutation &&
+        "mutationKey" in options.mutation &&
+        options.mutation.mutationKey
+        ? options
+        : { ...options, mutation: { ...options.mutation, mutationKey } }
+      : { mutation: { mutationKey }, request: undefined };
+
+    const mutationFn: MutationFunction<
+      Awaited<
+        ReturnType<typeof startOnboardingApiV1BoardsBoardIdOnboardingStartPost>
+      >,
+      { boardId: string; data: BoardOnboardingStart }
+    > = (props) => {
+      const { boardId, data } = props ?? {};
+
+      return startOnboardingApiV1BoardsBoardIdOnboardingStartPost(
+        boardId,
+        data,
+        requestOptions,
+      );
+    };
+
+    return { mutationFn, ...mutationOptions };
+  };
+
+export type StartOnboardingApiV1BoardsBoardIdOnboardingStartPostMutationResult =
+  NonNullable<
+    Awaited<
+      ReturnType<typeof startOnboardingApiV1BoardsBoardIdOnboardingStartPost>
+    >
+  >;
+export type StartOnboardingApiV1BoardsBoardIdOnboardingStartPostMutationBody =
+  BoardOnboardingStart;
+export type StartOnboardingApiV1BoardsBoardIdOnboardingStartPostMutationError =
+  HTTPValidationError;
+
+/**
+ * @summary Start Onboarding
+ */
+export const useStartOnboardingApiV1BoardsBoardIdOnboardingStartPost = <
+  TError = HTTPValidationError,
+  TContext = unknown,
+>(
+  options?: {
+    mutation?: UseMutationOptions<
+      Awaited<
+        ReturnType<typeof startOnboardingApiV1BoardsBoardIdOnboardingStartPost>
+      >,
+      TError,
+      { boardId: string; data: BoardOnboardingStart },
+      TContext
+    >;
+    request?: SecondParameter<typeof customFetch>;
+  },
+  queryClient?: QueryClient,
+): UseMutationResult<
+  Awaited<
+    ReturnType<typeof startOnboardingApiV1BoardsBoardIdOnboardingStartPost>
+  >,
+  TError,
+  { boardId: string; data: BoardOnboardingStart },
+  TContext
+> => {
+  return useMutation(
+    getStartOnboardingApiV1BoardsBoardIdOnboardingStartPostMutationOptions(
+      options,
+    ),
+    queryClient,
+  );
+};
+/**
+ * Send a user onboarding answer to the gateway agent.
+ * @summary Answer Onboarding
+ */
+export type answerOnboardingApiV1BoardsBoardIdOnboardingAnswerPostResponse200 =
+  {
+    data: BoardOnboardingRead;
+    status: 200;
+  };
+
+export type answerOnboardingApiV1BoardsBoardIdOnboardingAnswerPostResponse422 =
+  {
+    data: HTTPValidationError;
+    status: 422;
+  };
+
+export type answerOnboardingApiV1BoardsBoardIdOnboardingAnswerPostResponseSuccess =
+  answerOnboardingApiV1BoardsBoardIdOnboardingAnswerPostResponse200 & {
+    headers: Headers;
+  };
+export type answerOnboardingApiV1BoardsBoardIdOnboardingAnswerPostResponseError =
+  answerOnboardingApiV1BoardsBoardIdOnboardingAnswerPostResponse422 & {
+    headers: Headers;
+  };
+
+export type answerOnboardingApiV1BoardsBoardIdOnboardingAnswerPostResponse =
+  | answerOnboardingApiV1BoardsBoardIdOnboardingAnswerPostResponseSuccess
+  | answerOnboardingApiV1BoardsBoardIdOnboardingAnswerPostResponseError;
+
+export const getAnswerOnboardingApiV1BoardsBoardIdOnboardingAnswerPostUrl = (
+  boardId: string,
+) => {
+  return `/api/v1/boards/${boardId}/onboarding/answer`;
+};
+
+export const answerOnboardingApiV1BoardsBoardIdOnboardingAnswerPost = async (
+  boardId: string,
+  boardOnboardingAnswer: BoardOnboardingAnswer,
+  options?: RequestInit,
+): Promise<answerOnboardingApiV1BoardsBoardIdOnboardingAnswerPostResponse> => {
+  return customFetch<answerOnboardingApiV1BoardsBoardIdOnboardingAnswerPostResponse>(
+    getAnswerOnboardingApiV1BoardsBoardIdOnboardingAnswerPostUrl(boardId),
+    {
+      ...options,
+      method: "POST",
+      headers: { "Content-Type": "application/json", ...options?.headers },
+      body: JSON.stringify(boardOnboardingAnswer),
+    },
+  );
+};
+
+export const getAnswerOnboardingApiV1BoardsBoardIdOnboardingAnswerPostMutationOptions =
+  <TError = HTTPValidationError, TContext = unknown>(options?: {
+    mutation?: UseMutationOptions<
+      Awaited<
+        ReturnType<
+          typeof answerOnboardingApiV1BoardsBoardIdOnboardingAnswerPost
+        >
+      >,
+      TError,
+      { boardId: string; data: BoardOnboardingAnswer },
+      TContext
+    >;
+    request?: SecondParameter<typeof customFetch>;
+  }): UseMutationOptions<
+    Awaited<
+      ReturnType<typeof answerOnboardingApiV1BoardsBoardIdOnboardingAnswerPost>
+    >,
+    TError,
+    { boardId: string; data: BoardOnboardingAnswer },
+    TContext
+  > => {
+    const mutationKey = [
+      "answerOnboardingApiV1BoardsBoardIdOnboardingAnswerPost",
+    ];
+    const { mutation: mutationOptions, request: requestOptions } = options
+      ? options.mutation &&
+        "mutationKey" in options.mutation &&
+        options.mutation.mutationKey
+        ? options
+        : { ...options, mutation: { ...options.mutation, mutationKey } }
+      : { mutation: { mutationKey }, request: undefined };
+
+    const mutationFn: MutationFunction<
+      Awaited<
+        ReturnType<
+          typeof answerOnboardingApiV1BoardsBoardIdOnboardingAnswerPost
+        >
+      >,
+      { boardId: string; data: BoardOnboardingAnswer }
+    > = (props) => {
+      const { boardId, data } = props ?? {};
+
+      return answerOnboardingApiV1BoardsBoardIdOnboardingAnswerPost(
+        boardId,
+        data,
+        requestOptions,
+      );
+    };
+
+    return { mutationFn, ...mutationOptions };
+  };
+
+export type AnswerOnboardingApiV1BoardsBoardIdOnboardingAnswerPostMutationResult =
+  NonNullable<
+    Awaited<
+      ReturnType<typeof answerOnboardingApiV1BoardsBoardIdOnboardingAnswerPost>
+    >
+  >;
+export type AnswerOnboardingApiV1BoardsBoardIdOnboardingAnswerPostMutationBody =
+  BoardOnboardingAnswer;
+export type AnswerOnboardingApiV1BoardsBoardIdOnboardingAnswerPostMutationError =
+  HTTPValidationError;
+
+/**
+ * @summary Answer Onboarding
+ */
+export const useAnswerOnboardingApiV1BoardsBoardIdOnboardingAnswerPost = <
+  TError = HTTPValidationError,
+  TContext = unknown,
+>(
+  options?: {
+    mutation?: UseMutationOptions<
+      Awaited<
+        ReturnType<
+          typeof answerOnboardingApiV1BoardsBoardIdOnboardingAnswerPost
+        >
+      >,
+      TError,
+      { boardId: string; data: BoardOnboardingAnswer },
+      TContext
+    >;
+    request?: SecondParameter<typeof customFetch>;
+  },
+  queryClient?: QueryClient,
+): UseMutationResult<
+  Awaited<
+    ReturnType<typeof answerOnboardingApiV1BoardsBoardIdOnboardingAnswerPost>
+  >,
+  TError,
+  { boardId: string; data: BoardOnboardingAnswer },
+  TContext
+> => {
+  return useMutation(
+    getAnswerOnboardingApiV1BoardsBoardIdOnboardingAnswerPostMutationOptions(
+      options,
+    ),
+    queryClient,
+  );
+};
 /**
  * Store onboarding updates submitted by the gateway agent.
  * @summary Agent Onboarding Update
@@ -449,156 +741,6 @@ export const useAgentOnboardingUpdateApiV1BoardsBoardIdOnboardingAgentPost = <
     queryClient,
   );
 };
-/**
- * Send a user onboarding answer to the gateway agent.
- * @summary Answer Onboarding
- */
-export type answerOnboardingApiV1BoardsBoardIdOnboardingAnswerPostResponse200 =
-  {
-    data: BoardOnboardingRead;
-    status: 200;
-  };
-
-export type answerOnboardingApiV1BoardsBoardIdOnboardingAnswerPostResponse422 =
-  {
-    data: HTTPValidationError;
-    status: 422;
-  };
-
-export type answerOnboardingApiV1BoardsBoardIdOnboardingAnswerPostResponseSuccess =
-  answerOnboardingApiV1BoardsBoardIdOnboardingAnswerPostResponse200 & {
-    headers: Headers;
-  };
-export type answerOnboardingApiV1BoardsBoardIdOnboardingAnswerPostResponseError =
-  answerOnboardingApiV1BoardsBoardIdOnboardingAnswerPostResponse422 & {
-    headers: Headers;
-  };
-
-export type answerOnboardingApiV1BoardsBoardIdOnboardingAnswerPostResponse =
-  | answerOnboardingApiV1BoardsBoardIdOnboardingAnswerPostResponseSuccess
-  | answerOnboardingApiV1BoardsBoardIdOnboardingAnswerPostResponseError;
-
-export const getAnswerOnboardingApiV1BoardsBoardIdOnboardingAnswerPostUrl = (
-  boardId: string,
-) => {
-  return `/api/v1/boards/${boardId}/onboarding/answer`;
-};
-
-export const answerOnboardingApiV1BoardsBoardIdOnboardingAnswerPost = async (
-  boardId: string,
-  boardOnboardingAnswer: BoardOnboardingAnswer,
-  options?: RequestInit,
-): Promise<answerOnboardingApiV1BoardsBoardIdOnboardingAnswerPostResponse> => {
-  return customFetch<answerOnboardingApiV1BoardsBoardIdOnboardingAnswerPostResponse>(
-    getAnswerOnboardingApiV1BoardsBoardIdOnboardingAnswerPostUrl(boardId),
-    {
-      ...options,
-      method: "POST",
-      headers: { "Content-Type": "application/json", ...options?.headers },
-      body: JSON.stringify(boardOnboardingAnswer),
-    },
-  );
-};
-
-export const getAnswerOnboardingApiV1BoardsBoardIdOnboardingAnswerPostMutationOptions =
-  <TError = HTTPValidationError, TContext = unknown>(options?: {
-    mutation?: UseMutationOptions<
-      Awaited<
-        ReturnType<
-          typeof answerOnboardingApiV1BoardsBoardIdOnboardingAnswerPost
-        >
-      >,
-      TError,
-      { boardId: string; data: BoardOnboardingAnswer },
-      TContext
-    >;
-    request?: SecondParameter<typeof customFetch>;
-  }): UseMutationOptions<
-    Awaited<
-      ReturnType<typeof answerOnboardingApiV1BoardsBoardIdOnboardingAnswerPost>
-    >,
-    TError,
-    { boardId: string; data: BoardOnboardingAnswer },
-    TContext
-  > => {
-    const mutationKey = [
-      "answerOnboardingApiV1BoardsBoardIdOnboardingAnswerPost",
-    ];
-    const { mutation: mutationOptions, request: requestOptions } = options
-      ? options.mutation &&
-        "mutationKey" in options.mutation &&
-        options.mutation.mutationKey
-        ? options
-        : { ...options, mutation: { ...options.mutation, mutationKey } }
-      : { mutation: { mutationKey }, request: undefined };
-
-    const mutationFn: MutationFunction<
-      Awaited<
-        ReturnType<
-          typeof answerOnboardingApiV1BoardsBoardIdOnboardingAnswerPost
-        >
-      >,
-      { boardId: string; data: BoardOnboardingAnswer }
-    > = (props) => {
-      const { boardId, data } = props ?? {};
-
-      return answerOnboardingApiV1BoardsBoardIdOnboardingAnswerPost(
-        boardId,
-        data,
-        requestOptions,
-      );
-    };
-
-    return { mutationFn, ...mutationOptions };
-  };
-
-export type AnswerOnboardingApiV1BoardsBoardIdOnboardingAnswerPostMutationResult =
-  NonNullable<
-    Awaited<
-      ReturnType<typeof answerOnboardingApiV1BoardsBoardIdOnboardingAnswerPost>
-    >
-  >;
-export type AnswerOnboardingApiV1BoardsBoardIdOnboardingAnswerPostMutationBody =
-  BoardOnboardingAnswer;
-export type AnswerOnboardingApiV1BoardsBoardIdOnboardingAnswerPostMutationError =
-  HTTPValidationError;
-
-/**
- * @summary Answer Onboarding
- */
-export const useAnswerOnboardingApiV1BoardsBoardIdOnboardingAnswerPost = <
-  TError = HTTPValidationError,
-  TContext = unknown,
->(
-  options?: {
-    mutation?: UseMutationOptions<
-      Awaited<
-        ReturnType<
-          typeof answerOnboardingApiV1BoardsBoardIdOnboardingAnswerPost
-        >
-      >,
-      TError,
-      { boardId: string; data: BoardOnboardingAnswer },
-      TContext
-    >;
-    request?: SecondParameter<typeof customFetch>;
-  },
-  queryClient?: QueryClient,
-): UseMutationResult<
-  Awaited<
-    ReturnType<typeof answerOnboardingApiV1BoardsBoardIdOnboardingAnswerPost>
-  >,
-  TError,
-  { boardId: string; data: BoardOnboardingAnswer },
-  TContext
-> => {
-  return useMutation(
-    getAnswerOnboardingApiV1BoardsBoardIdOnboardingAnswerPostMutationOptions(
-      options,
-    ),
-    queryClient,
-  );
-};
 /**
  * Confirm onboarding results and provision the board lead agent.
  * @summary Confirm Onboarding
@@ -753,145 +895,3 @@ export const useConfirmOnboardingApiV1BoardsBoardIdOnboardingConfirmPost = <
     queryClient,
   );
 };
-/**
- * Start onboarding and send instructions to the gateway agent.
- * @summary Start Onboarding
- */
-export type startOnboardingApiV1BoardsBoardIdOnboardingStartPostResponse200 = {
-  data: BoardOnboardingRead;
-  status: 200;
-};
-
-export type startOnboardingApiV1BoardsBoardIdOnboardingStartPostResponse422 = {
-  data: HTTPValidationError;
-  status: 422;
-};
-
-export type startOnboardingApiV1BoardsBoardIdOnboardingStartPostResponseSuccess =
-  startOnboardingApiV1BoardsBoardIdOnboardingStartPostResponse200 & {
-    headers: Headers;
-  };
-export type startOnboardingApiV1BoardsBoardIdOnboardingStartPostResponseError =
-  startOnboardingApiV1BoardsBoardIdOnboardingStartPostResponse422 & {
-    headers: Headers;
-  };
-
-export type startOnboardingApiV1BoardsBoardIdOnboardingStartPostResponse =
-  | startOnboardingApiV1BoardsBoardIdOnboardingStartPostResponseSuccess
-  | startOnboardingApiV1BoardsBoardIdOnboardingStartPostResponseError;
-
-export const getStartOnboardingApiV1BoardsBoardIdOnboardingStartPostUrl = (
-  boardId: string,
-) => {
-  return `/api/v1/boards/${boardId}/onboarding/start`;
-};
-
-export const startOnboardingApiV1BoardsBoardIdOnboardingStartPost = async (
-  boardId: string,
-  boardOnboardingStart: BoardOnboardingStart,
-  options?: RequestInit,
-): Promise<startOnboardingApiV1BoardsBoardIdOnboardingStartPostResponse> => {
-  return customFetch<startOnboardingApiV1BoardsBoardIdOnboardingStartPostResponse>(
-    getStartOnboardingApiV1BoardsBoardIdOnboardingStartPostUrl(boardId),
-    {
-      ...options,
-      method: "POST",
-      headers: { "Content-Type": "application/json", ...options?.headers },
-      body: JSON.stringify(boardOnboardingStart),
-    },
-  );
-};
-
-export const getStartOnboardingApiV1BoardsBoardIdOnboardingStartPostMutationOptions =
-  <TError = HTTPValidationError, TContext = unknown>(options?: {
-    mutation?: UseMutationOptions<
-      Awaited<
-        ReturnType<typeof startOnboardingApiV1BoardsBoardIdOnboardingStartPost>
-      >,
-      TError,
-      { boardId: string; data: BoardOnboardingStart },
-      TContext
-    >;
-    request?: SecondParameter<typeof customFetch>;
-  }): UseMutationOptions<
-    Awaited<
-      ReturnType<typeof startOnboardingApiV1BoardsBoardIdOnboardingStartPost>
-    >,
-    TError,
-    { boardId: string; data: BoardOnboardingStart },
-    TContext
-  > => {
-    const mutationKey = [
-      "startOnboardingApiV1BoardsBoardIdOnboardingStartPost",
-    ];
-    const { mutation: mutationOptions, request: requestOptions } = options
-      ? options.mutation &&
-        "mutationKey" in options.mutation &&
-        options.mutation.mutationKey
-        ? options
-        : { ...options, mutation: { ...options.mutation, mutationKey } }
-      : { mutation: { mutationKey }, request: undefined };
-
-    const mutationFn: MutationFunction<
-      Awaited<
-        ReturnType<typeof startOnboardingApiV1BoardsBoardIdOnboardingStartPost>
-      >,
-      { boardId: string; data: BoardOnboardingStart }
-    > = (props) => {
-      const { boardId, data } = props ?? {};
-
-      return startOnboardingApiV1BoardsBoardIdOnboardingStartPost(
-        boardId,
-        data,
-        requestOptions,
-      );
-    };
-
-    return { mutationFn, ...mutationOptions };
-  };
-
-export type StartOnboardingApiV1BoardsBoardIdOnboardingStartPostMutationResult =
-  NonNullable<
-    Awaited<
-      ReturnType<typeof startOnboardingApiV1BoardsBoardIdOnboardingStartPost>
-    >
-  >;
-export type StartOnboardingApiV1BoardsBoardIdOnboardingStartPostMutationBody =
-  BoardOnboardingStart;
-export type StartOnboardingApiV1BoardsBoardIdOnboardingStartPostMutationError =
-  HTTPValidationError;
-
-/**
- * @summary Start Onboarding
- */
-export const useStartOnboardingApiV1BoardsBoardIdOnboardingStartPost = <
-  TError = HTTPValidationError,
-  TContext = unknown,
->(
-  options?: {
-    mutation?: UseMutationOptions<
-      Awaited<
-        ReturnType<typeof startOnboardingApiV1BoardsBoardIdOnboardingStartPost>
-      >,
-      TError,
-      { boardId: string; data: BoardOnboardingStart },
-      TContext
-    >;
-    request?: SecondParameter<typeof customFetch>;
-  },
-  queryClient?: QueryClient,
-): UseMutationResult<
-  Awaited<
-    ReturnType<typeof startOnboardingApiV1BoardsBoardIdOnboardingStartPost>
-  >,
-  TError,
-  { boardId: string; data: BoardOnboardingStart },
-  TContext
-> => {
-  return useMutation(
-    getStartOnboardingApiV1BoardsBoardIdOnboardingStartPostMutationOptions(
-      options,
-    ),
-    queryClient,
-  );
-};

frontend/src/api/generated/board-webhooks/board-webhooks.ts

@@ -435,163 +435,6 @@ export const useCreateBoardWebhookApiV1BoardsBoardIdWebhooksPost = <
     queryClient,
   );
 };
-/**
- * Delete a webhook and its stored payload rows.
- * @summary Delete Board Webhook
- */
-export type deleteBoardWebhookApiV1BoardsBoardIdWebhooksWebhookIdDeleteResponse200 =
-  {
-    data: OkResponse;
-    status: 200;
-  };
-
-export type deleteBoardWebhookApiV1BoardsBoardIdWebhooksWebhookIdDeleteResponse422 =
-  {
-    data: HTTPValidationError;
-    status: 422;
-  };
-
-export type deleteBoardWebhookApiV1BoardsBoardIdWebhooksWebhookIdDeleteResponseSuccess =
-  deleteBoardWebhookApiV1BoardsBoardIdWebhooksWebhookIdDeleteResponse200 & {
-    headers: Headers;
-  };
-export type deleteBoardWebhookApiV1BoardsBoardIdWebhooksWebhookIdDeleteResponseError =
-  deleteBoardWebhookApiV1BoardsBoardIdWebhooksWebhookIdDeleteResponse422 & {
-    headers: Headers;
-  };
-
-export type deleteBoardWebhookApiV1BoardsBoardIdWebhooksWebhookIdDeleteResponse =
-
-    | deleteBoardWebhookApiV1BoardsBoardIdWebhooksWebhookIdDeleteResponseSuccess
-    | deleteBoardWebhookApiV1BoardsBoardIdWebhooksWebhookIdDeleteResponseError;
-
-export const getDeleteBoardWebhookApiV1BoardsBoardIdWebhooksWebhookIdDeleteUrl =
-  (boardId: string, webhookId: string) => {
-    return `/api/v1/boards/${boardId}/webhooks/${webhookId}`;
-  };
-
-export const deleteBoardWebhookApiV1BoardsBoardIdWebhooksWebhookIdDelete =
-  async (
-    boardId: string,
-    webhookId: string,
-    options?: RequestInit,
-  ): Promise<deleteBoardWebhookApiV1BoardsBoardIdWebhooksWebhookIdDeleteResponse> => {
-    return customFetch<deleteBoardWebhookApiV1BoardsBoardIdWebhooksWebhookIdDeleteResponse>(
-      getDeleteBoardWebhookApiV1BoardsBoardIdWebhooksWebhookIdDeleteUrl(
-        boardId,
-        webhookId,
-      ),
-      {
-        ...options,
-        method: "DELETE",
-      },
-    );
-  };
-
-export const getDeleteBoardWebhookApiV1BoardsBoardIdWebhooksWebhookIdDeleteMutationOptions =
-  <TError = HTTPValidationError, TContext = unknown>(options?: {
-    mutation?: UseMutationOptions<
-      Awaited<
-        ReturnType<
-          typeof deleteBoardWebhookApiV1BoardsBoardIdWebhooksWebhookIdDelete
-        >
-      >,
-      TError,
-      { boardId: string; webhookId: string },
-      TContext
-    >;
-    request?: SecondParameter<typeof customFetch>;
-  }): UseMutationOptions<
-    Awaited<
-      ReturnType<
-        typeof deleteBoardWebhookApiV1BoardsBoardIdWebhooksWebhookIdDelete
-      >
-    >,
-    TError,
-    { boardId: string; webhookId: string },
-    TContext
-  > => {
-    const mutationKey = [
-      "deleteBoardWebhookApiV1BoardsBoardIdWebhooksWebhookIdDelete",
-    ];
-    const { mutation: mutationOptions, request: requestOptions } = options
-      ? options.mutation &&
-        "mutationKey" in options.mutation &&
-        options.mutation.mutationKey
-        ? options
-        : { ...options, mutation: { ...options.mutation, mutationKey } }
-      : { mutation: { mutationKey }, request: undefined };
-
-    const mutationFn: MutationFunction<
-      Awaited<
-        ReturnType<
-          typeof deleteBoardWebhookApiV1BoardsBoardIdWebhooksWebhookIdDelete
-        >
-      >,
-      { boardId: string; webhookId: string }
-    > = (props) => {
-      const { boardId, webhookId } = props ?? {};
-
-      return deleteBoardWebhookApiV1BoardsBoardIdWebhooksWebhookIdDelete(
-        boardId,
-        webhookId,
-        requestOptions,
-      );
-    };
-
-    return { mutationFn, ...mutationOptions };
-  };
-
-export type DeleteBoardWebhookApiV1BoardsBoardIdWebhooksWebhookIdDeleteMutationResult =
-  NonNullable<
-    Awaited<
-      ReturnType<
-        typeof deleteBoardWebhookApiV1BoardsBoardIdWebhooksWebhookIdDelete
-      >
-    >
-  >;
-
-export type DeleteBoardWebhookApiV1BoardsBoardIdWebhooksWebhookIdDeleteMutationError =
-  HTTPValidationError;
-
-/**
- * @summary Delete Board Webhook
- */
-export const useDeleteBoardWebhookApiV1BoardsBoardIdWebhooksWebhookIdDelete = <
-  TError = HTTPValidationError,
-  TContext = unknown,
->(
-  options?: {
-    mutation?: UseMutationOptions<
-      Awaited<
-        ReturnType<
-          typeof deleteBoardWebhookApiV1BoardsBoardIdWebhooksWebhookIdDelete
-        >
-      >,
-      TError,
-      { boardId: string; webhookId: string },
-      TContext
-    >;
-    request?: SecondParameter<typeof customFetch>;
-  },
-  queryClient?: QueryClient,
-): UseMutationResult<
-  Awaited<
-    ReturnType<
-      typeof deleteBoardWebhookApiV1BoardsBoardIdWebhooksWebhookIdDelete
-    >
-  >,
-  TError,
-  { boardId: string; webhookId: string },
-  TContext
-> => {
-  return useMutation(
-    getDeleteBoardWebhookApiV1BoardsBoardIdWebhooksWebhookIdDeleteMutationOptions(
-      options,
-    ),
-    queryClient,
-  );
-};
 /**
  * Get one board webhook configuration.
  * @summary Get Board Webhook
@@ -1031,6 +874,163 @@ export const useUpdateBoardWebhookApiV1BoardsBoardIdWebhooksWebhookIdPatch = <
     queryClient,
   );
 };
+/**
+ * Delete a webhook and its stored payload rows.
+ * @summary Delete Board Webhook
+ */
+export type deleteBoardWebhookApiV1BoardsBoardIdWebhooksWebhookIdDeleteResponse200 =
+  {
+    data: OkResponse;
+    status: 200;
+  };
+
+export type deleteBoardWebhookApiV1BoardsBoardIdWebhooksWebhookIdDeleteResponse422 =
+  {
+    data: HTTPValidationError;
+    status: 422;
+  };
+
+export type deleteBoardWebhookApiV1BoardsBoardIdWebhooksWebhookIdDeleteResponseSuccess =
+  deleteBoardWebhookApiV1BoardsBoardIdWebhooksWebhookIdDeleteResponse200 & {
+    headers: Headers;
+  };
+export type deleteBoardWebhookApiV1BoardsBoardIdWebhooksWebhookIdDeleteResponseError =
+  deleteBoardWebhookApiV1BoardsBoardIdWebhooksWebhookIdDeleteResponse422 & {
+    headers: Headers;
+  };
+
+export type deleteBoardWebhookApiV1BoardsBoardIdWebhooksWebhookIdDeleteResponse =
+
+    | deleteBoardWebhookApiV1BoardsBoardIdWebhooksWebhookIdDeleteResponseSuccess
+    | deleteBoardWebhookApiV1BoardsBoardIdWebhooksWebhookIdDeleteResponseError;
+
+export const getDeleteBoardWebhookApiV1BoardsBoardIdWebhooksWebhookIdDeleteUrl =
+  (boardId: string, webhookId: string) => {
+    return `/api/v1/boards/${boardId}/webhooks/${webhookId}`;
+  };
+
+export const deleteBoardWebhookApiV1BoardsBoardIdWebhooksWebhookIdDelete =
+  async (
+    boardId: string,
+    webhookId: string,
+    options?: RequestInit,
+  ): Promise<deleteBoardWebhookApiV1BoardsBoardIdWebhooksWebhookIdDeleteResponse> => {
+    return customFetch<deleteBoardWebhookApiV1BoardsBoardIdWebhooksWebhookIdDeleteResponse>(
+      getDeleteBoardWebhookApiV1BoardsBoardIdWebhooksWebhookIdDeleteUrl(
+        boardId,
+        webhookId,
+      ),
+      {
+        ...options,
+        method: "DELETE",
+      },
+    );
+  };
+
+export const getDeleteBoardWebhookApiV1BoardsBoardIdWebhooksWebhookIdDeleteMutationOptions =
+  <TError = HTTPValidationError, TContext = unknown>(options?: {
+    mutation?: UseMutationOptions<
+      Awaited<
+        ReturnType<
+          typeof deleteBoardWebhookApiV1BoardsBoardIdWebhooksWebhookIdDelete
+        >
+      >,
+      TError,
+      { boardId: string; webhookId: string },
+      TContext
+    >;
+    request?: SecondParameter<typeof customFetch>;
+  }): UseMutationOptions<
+    Awaited<
+      ReturnType<
+        typeof deleteBoardWebhookApiV1BoardsBoardIdWebhooksWebhookIdDelete
+      >
+    >,
+    TError,
+    { boardId: string; webhookId: string },
+    TContext
+  > => {
+    const mutationKey = [
+      "deleteBoardWebhookApiV1BoardsBoardIdWebhooksWebhookIdDelete",
+    ];
+    const { mutation: mutationOptions, request: requestOptions } = options
+      ? options.mutation &&
+        "mutationKey" in options.mutation &&
+        options.mutation.mutationKey
+        ? options
+        : { ...options, mutation: { ...options.mutation, mutationKey } }
+      : { mutation: { mutationKey }, request: undefined };
+
+    const mutationFn: MutationFunction<
+      Awaited<
+        ReturnType<
+          typeof deleteBoardWebhookApiV1BoardsBoardIdWebhooksWebhookIdDelete
+        >
+      >,
+      { boardId: string; webhookId: string }
+    > = (props) => {
+      const { boardId, webhookId } = props ?? {};
+
+      return deleteBoardWebhookApiV1BoardsBoardIdWebhooksWebhookIdDelete(
+        boardId,
+        webhookId,
+        requestOptions,
+      );
+    };
+
+    return { mutationFn, ...mutationOptions };
+  };
+
+export type DeleteBoardWebhookApiV1BoardsBoardIdWebhooksWebhookIdDeleteMutationResult =
+  NonNullable<
+    Awaited<
+      ReturnType<
+        typeof deleteBoardWebhookApiV1BoardsBoardIdWebhooksWebhookIdDelete
+      >
+    >
+  >;
+
+export type DeleteBoardWebhookApiV1BoardsBoardIdWebhooksWebhookIdDeleteMutationError =
+  HTTPValidationError;
+
+/**
+ * @summary Delete Board Webhook
+ */
+export const useDeleteBoardWebhookApiV1BoardsBoardIdWebhooksWebhookIdDelete = <
+  TError = HTTPValidationError,
+  TContext = unknown,
+>(
+  options?: {
+    mutation?: UseMutationOptions<
+      Awaited<
+        ReturnType<
+          typeof deleteBoardWebhookApiV1BoardsBoardIdWebhooksWebhookIdDelete
+        >
+      >,
+      TError,
+      { boardId: string; webhookId: string },
+      TContext
+    >;
+    request?: SecondParameter<typeof customFetch>;
+  },
+  queryClient?: QueryClient,
+): UseMutationResult<
+  Awaited<
+    ReturnType<
+      typeof deleteBoardWebhookApiV1BoardsBoardIdWebhooksWebhookIdDelete
+    >
+  >,
+  TError,
+  { boardId: string; webhookId: string },
+  TContext
+> => {
+  return useMutation(
+    getDeleteBoardWebhookApiV1BoardsBoardIdWebhooksWebhookIdDeleteMutationOptions(
+      options,
+    ),
+    queryClient,
+  );
+};
 /**
  * Open inbound webhook endpoint that stores payloads and nudges the board lead.
  * @summary Ingest Board Webhook

frontend/src/api/generated/boards/boards.ts

@@ -363,123 +363,6 @@ export const useCreateBoardApiV1BoardsPost = <
     queryClient,
   );
 };
-/**
- * Delete a board and all dependent records.
- * @summary Delete Board
- */
-export type deleteBoardApiV1BoardsBoardIdDeleteResponse200 = {
-  data: OkResponse;
-  status: 200;
-};
-
-export type deleteBoardApiV1BoardsBoardIdDeleteResponse422 = {
-  data: HTTPValidationError;
-  status: 422;
-};
-
-export type deleteBoardApiV1BoardsBoardIdDeleteResponseSuccess =
-  deleteBoardApiV1BoardsBoardIdDeleteResponse200 & {
-    headers: Headers;
-  };
-export type deleteBoardApiV1BoardsBoardIdDeleteResponseError =
-  deleteBoardApiV1BoardsBoardIdDeleteResponse422 & {
-    headers: Headers;
-  };
-
-export type deleteBoardApiV1BoardsBoardIdDeleteResponse =
-  | deleteBoardApiV1BoardsBoardIdDeleteResponseSuccess
-  | deleteBoardApiV1BoardsBoardIdDeleteResponseError;
-
-export const getDeleteBoardApiV1BoardsBoardIdDeleteUrl = (boardId: string) => {
-  return `/api/v1/boards/${boardId}`;
-};
-
-export const deleteBoardApiV1BoardsBoardIdDelete = async (
-  boardId: string,
-  options?: RequestInit,
-): Promise<deleteBoardApiV1BoardsBoardIdDeleteResponse> => {
-  return customFetch<deleteBoardApiV1BoardsBoardIdDeleteResponse>(
-    getDeleteBoardApiV1BoardsBoardIdDeleteUrl(boardId),
-    {
-      ...options,
-      method: "DELETE",
-    },
-  );
-};
-
-export const getDeleteBoardApiV1BoardsBoardIdDeleteMutationOptions = <
-  TError = HTTPValidationError,
-  TContext = unknown,
->(options?: {
-  mutation?: UseMutationOptions<
-    Awaited<ReturnType<typeof deleteBoardApiV1BoardsBoardIdDelete>>,
-    TError,
-    { boardId: string },
-    TContext
-  >;
-  request?: SecondParameter<typeof customFetch>;
-}): UseMutationOptions<
-  Awaited<ReturnType<typeof deleteBoardApiV1BoardsBoardIdDelete>>,
-  TError,
-  { boardId: string },
-  TContext
-> => {
-  const mutationKey = ["deleteBoardApiV1BoardsBoardIdDelete"];
-  const { mutation: mutationOptions, request: requestOptions } = options
-    ? options.mutation &&
-      "mutationKey" in options.mutation &&
-      options.mutation.mutationKey
-      ? options
-      : { ...options, mutation: { ...options.mutation, mutationKey } }
-    : { mutation: { mutationKey }, request: undefined };
-
-  const mutationFn: MutationFunction<
-    Awaited<ReturnType<typeof deleteBoardApiV1BoardsBoardIdDelete>>,
-    { boardId: string }
-  > = (props) => {
-    const { boardId } = props ?? {};
-
-    return deleteBoardApiV1BoardsBoardIdDelete(boardId, requestOptions);
-  };
-
-  return { mutationFn, ...mutationOptions };
-};
-
-export type DeleteBoardApiV1BoardsBoardIdDeleteMutationResult = NonNullable<
-  Awaited<ReturnType<typeof deleteBoardApiV1BoardsBoardIdDelete>>
->;
-
-export type DeleteBoardApiV1BoardsBoardIdDeleteMutationError =
-  HTTPValidationError;
-
-/**
- * @summary Delete Board
- */
-export const useDeleteBoardApiV1BoardsBoardIdDelete = <
-  TError = HTTPValidationError,
-  TContext = unknown,
->(
-  options?: {
-    mutation?: UseMutationOptions<
-      Awaited<ReturnType<typeof deleteBoardApiV1BoardsBoardIdDelete>>,
-      TError,
-      { boardId: string },
-      TContext
-    >;
-    request?: SecondParameter<typeof customFetch>;
-  },
-  queryClient?: QueryClient,
-): UseMutationResult<
-  Awaited<ReturnType<typeof deleteBoardApiV1BoardsBoardIdDelete>>,
-  TError,
-  { boardId: string },
-  TContext
-> => {
-  return useMutation(
-    getDeleteBoardApiV1BoardsBoardIdDeleteMutationOptions(options),
-    queryClient,
-  );
-};
 /**
  * Get a board by id.
  * @summary Get Board
@@ -800,6 +683,362 @@ export const useUpdateBoardApiV1BoardsBoardIdPatch = <
     queryClient,
   );
 };
+/**
+ * Delete a board and all dependent records.
+ * @summary Delete Board
+ */
+export type deleteBoardApiV1BoardsBoardIdDeleteResponse200 = {
+  data: OkResponse;
+  status: 200;
+};
+
+export type deleteBoardApiV1BoardsBoardIdDeleteResponse422 = {
+  data: HTTPValidationError;
+  status: 422;
+};
+
+export type deleteBoardApiV1BoardsBoardIdDeleteResponseSuccess =
+  deleteBoardApiV1BoardsBoardIdDeleteResponse200 & {
+    headers: Headers;
+  };
+export type deleteBoardApiV1BoardsBoardIdDeleteResponseError =
+  deleteBoardApiV1BoardsBoardIdDeleteResponse422 & {
+    headers: Headers;
+  };
+
+export type deleteBoardApiV1BoardsBoardIdDeleteResponse =
+  | deleteBoardApiV1BoardsBoardIdDeleteResponseSuccess
+  | deleteBoardApiV1BoardsBoardIdDeleteResponseError;
+
+export const getDeleteBoardApiV1BoardsBoardIdDeleteUrl = (boardId: string) => {
+  return `/api/v1/boards/${boardId}`;
+};
+
+export const deleteBoardApiV1BoardsBoardIdDelete = async (
+  boardId: string,
+  options?: RequestInit,
+): Promise<deleteBoardApiV1BoardsBoardIdDeleteResponse> => {
+  return customFetch<deleteBoardApiV1BoardsBoardIdDeleteResponse>(
+    getDeleteBoardApiV1BoardsBoardIdDeleteUrl(boardId),
+    {
+      ...options,
+      method: "DELETE",
+    },
+  );
+};
+
+export const getDeleteBoardApiV1BoardsBoardIdDeleteMutationOptions = <
+  TError = HTTPValidationError,
+  TContext = unknown,
+>(options?: {
+  mutation?: UseMutationOptions<
+    Awaited<ReturnType<typeof deleteBoardApiV1BoardsBoardIdDelete>>,
+    TError,
+    { boardId: string },
+    TContext
+  >;
+  request?: SecondParameter<typeof customFetch>;
+}): UseMutationOptions<
+  Awaited<ReturnType<typeof deleteBoardApiV1BoardsBoardIdDelete>>,
+  TError,
+  { boardId: string },
+  TContext
+> => {
+  const mutationKey = ["deleteBoardApiV1BoardsBoardIdDelete"];
+  const { mutation: mutationOptions, request: requestOptions } = options
+    ? options.mutation &&
+      "mutationKey" in options.mutation &&
+      options.mutation.mutationKey
+      ? options
+      : { ...options, mutation: { ...options.mutation, mutationKey } }
+    : { mutation: { mutationKey }, request: undefined };
+
+  const mutationFn: MutationFunction<
+    Awaited<ReturnType<typeof deleteBoardApiV1BoardsBoardIdDelete>>,
+    { boardId: string }
+  > = (props) => {
+    const { boardId } = props ?? {};
+
+    return deleteBoardApiV1BoardsBoardIdDelete(boardId, requestOptions);
+  };
+
+  return { mutationFn, ...mutationOptions };
+};
+
+export type DeleteBoardApiV1BoardsBoardIdDeleteMutationResult = NonNullable<
+  Awaited<ReturnType<typeof deleteBoardApiV1BoardsBoardIdDelete>>
+>;
+
+export type DeleteBoardApiV1BoardsBoardIdDeleteMutationError =
+  HTTPValidationError;
+
+/**
+ * @summary Delete Board
+ */
+export const useDeleteBoardApiV1BoardsBoardIdDelete = <
+  TError = HTTPValidationError,
+  TContext = unknown,
+>(
+  options?: {
+    mutation?: UseMutationOptions<
+      Awaited<ReturnType<typeof deleteBoardApiV1BoardsBoardIdDelete>>,
+      TError,
+      { boardId: string },
+      TContext
+    >;
+    request?: SecondParameter<typeof customFetch>;
+  },
+  queryClient?: QueryClient,
+): UseMutationResult<
+  Awaited<ReturnType<typeof deleteBoardApiV1BoardsBoardIdDelete>>,
+  TError,
+  { boardId: string },
+  TContext
+> => {
+  return useMutation(
+    getDeleteBoardApiV1BoardsBoardIdDeleteMutationOptions(options),
+    queryClient,
+  );
+};
+/**
+ * Get a board snapshot view model.
+ * @summary Get Board Snapshot
+ */
+export type getBoardSnapshotApiV1BoardsBoardIdSnapshotGetResponse200 = {
+  data: BoardSnapshot;
+  status: 200;
+};
+
+export type getBoardSnapshotApiV1BoardsBoardIdSnapshotGetResponse422 = {
+  data: HTTPValidationError;
+  status: 422;
+};
+
+export type getBoardSnapshotApiV1BoardsBoardIdSnapshotGetResponseSuccess =
+  getBoardSnapshotApiV1BoardsBoardIdSnapshotGetResponse200 & {
+    headers: Headers;
+  };
+export type getBoardSnapshotApiV1BoardsBoardIdSnapshotGetResponseError =
+  getBoardSnapshotApiV1BoardsBoardIdSnapshotGetResponse422 & {
+    headers: Headers;
+  };
+
+export type getBoardSnapshotApiV1BoardsBoardIdSnapshotGetResponse =
+  | getBoardSnapshotApiV1BoardsBoardIdSnapshotGetResponseSuccess
+  | getBoardSnapshotApiV1BoardsBoardIdSnapshotGetResponseError;
+
+export const getGetBoardSnapshotApiV1BoardsBoardIdSnapshotGetUrl = (
+  boardId: string,
+) => {
+  return `/api/v1/boards/${boardId}/snapshot`;
+};
+
+export const getBoardSnapshotApiV1BoardsBoardIdSnapshotGet = async (
+  boardId: string,
+  options?: RequestInit,
+): Promise<getBoardSnapshotApiV1BoardsBoardIdSnapshotGetResponse> => {
+  return customFetch<getBoardSnapshotApiV1BoardsBoardIdSnapshotGetResponse>(
+    getGetBoardSnapshotApiV1BoardsBoardIdSnapshotGetUrl(boardId),
+    {
+      ...options,
+      method: "GET",
+    },
+  );
+};
+
+export const getGetBoardSnapshotApiV1BoardsBoardIdSnapshotGetQueryKey = (
+  boardId: string,
+) => {
+  return [`/api/v1/boards/${boardId}/snapshot`] as const;
+};
+
+export const getGetBoardSnapshotApiV1BoardsBoardIdSnapshotGetQueryOptions = <
+  TData = Awaited<
+    ReturnType<typeof getBoardSnapshotApiV1BoardsBoardIdSnapshotGet>
+  >,
+  TError = HTTPValidationError,
+>(
+  boardId: string,
+  options?: {
+    query?: Partial<
+      UseQueryOptions<
+        Awaited<
+          ReturnType<typeof getBoardSnapshotApiV1BoardsBoardIdSnapshotGet>
+        >,
+        TError,
+        TData
+      >
+    >;
+    request?: SecondParameter<typeof customFetch>;
+  },
+) => {
+  const { query: queryOptions, request: requestOptions } = options ?? {};
+
+  const queryKey =
+    queryOptions?.queryKey ??
+    getGetBoardSnapshotApiV1BoardsBoardIdSnapshotGetQueryKey(boardId);
+
+  const queryFn: QueryFunction<
+    Awaited<ReturnType<typeof getBoardSnapshotApiV1BoardsBoardIdSnapshotGet>>
+  > = ({ signal }) =>
+    getBoardSnapshotApiV1BoardsBoardIdSnapshotGet(boardId, {
+      signal,
+      ...requestOptions,
+    });
+
+  return {
+    queryKey,
+    queryFn,
+    enabled: !!boardId,
+    ...queryOptions,
+  } as UseQueryOptions<
+    Awaited<ReturnType<typeof getBoardSnapshotApiV1BoardsBoardIdSnapshotGet>>,
+    TError,
+    TData
+  > & { queryKey: DataTag<QueryKey, TData, TError> };
+};
+
+export type GetBoardSnapshotApiV1BoardsBoardIdSnapshotGetQueryResult =
+  NonNullable<
+    Awaited<ReturnType<typeof getBoardSnapshotApiV1BoardsBoardIdSnapshotGet>>
+  >;
+export type GetBoardSnapshotApiV1BoardsBoardIdSnapshotGetQueryError =
+  HTTPValidationError;
+
+export function useGetBoardSnapshotApiV1BoardsBoardIdSnapshotGet<
+  TData = Awaited<
+    ReturnType<typeof getBoardSnapshotApiV1BoardsBoardIdSnapshotGet>
+  >,
+  TError = HTTPValidationError,
+>(
+  boardId: string,
+  options: {
+    query: Partial<
+      UseQueryOptions<
+        Awaited<
+          ReturnType<typeof getBoardSnapshotApiV1BoardsBoardIdSnapshotGet>
+        >,
+        TError,
+        TData
+      >
+    > &
+      Pick<
+        DefinedInitialDataOptions<
+          Awaited<
+            ReturnType<typeof getBoardSnapshotApiV1BoardsBoardIdSnapshotGet>
+          >,
+          TError,
+          Awaited<
+            ReturnType<typeof getBoardSnapshotApiV1BoardsBoardIdSnapshotGet>
+          >
+        >,
+        "initialData"
+      >;
+    request?: SecondParameter<typeof customFetch>;
+  },
+  queryClient?: QueryClient,
+): DefinedUseQueryResult<TData, TError> & {
+  queryKey: DataTag<QueryKey, TData, TError>;
+};
+export function useGetBoardSnapshotApiV1BoardsBoardIdSnapshotGet<
+  TData = Awaited<
+    ReturnType<typeof getBoardSnapshotApiV1BoardsBoardIdSnapshotGet>
+  >,
+  TError = HTTPValidationError,
+>(
+  boardId: string,
+  options?: {
+    query?: Partial<
+      UseQueryOptions<
+        Awaited<
+          ReturnType<typeof getBoardSnapshotApiV1BoardsBoardIdSnapshotGet>
+        >,
+        TError,
+        TData
+      >
+    > &
+      Pick<
+        UndefinedInitialDataOptions<
+          Awaited<
+            ReturnType<typeof getBoardSnapshotApiV1BoardsBoardIdSnapshotGet>
+          >,
+          TError,
+          Awaited<
+            ReturnType<typeof getBoardSnapshotApiV1BoardsBoardIdSnapshotGet>
+          >
+        >,
+        "initialData"
+      >;
+    request?: SecondParameter<typeof customFetch>;
+  },
+  queryClient?: QueryClient,
+): UseQueryResult<TData, TError> & {
+  queryKey: DataTag<QueryKey, TData, TError>;
+};
+export function useGetBoardSnapshotApiV1BoardsBoardIdSnapshotGet<
+  TData = Awaited<
+    ReturnType<typeof getBoardSnapshotApiV1BoardsBoardIdSnapshotGet>
+  >,
+  TError = HTTPValidationError,
+>(
+  boardId: string,
+  options?: {
+    query?: Partial<
+      UseQueryOptions<
+        Awaited<
+          ReturnType<typeof getBoardSnapshotApiV1BoardsBoardIdSnapshotGet>
+        >,
+        TError,
+        TData
+      >
+    >;
+    request?: SecondParameter<typeof customFetch>;
+  },
+  queryClient?: QueryClient,
+): UseQueryResult<TData, TError> & {
+  queryKey: DataTag<QueryKey, TData, TError>;
+};
+/**
+ * @summary Get Board Snapshot
+ */
+
+export function useGetBoardSnapshotApiV1BoardsBoardIdSnapshotGet<
+  TData = Awaited<
+    ReturnType<typeof getBoardSnapshotApiV1BoardsBoardIdSnapshotGet>
+  >,
+  TError = HTTPValidationError,
+>(
+  boardId: string,
+  options?: {
+    query?: Partial<
+      UseQueryOptions<
+        Awaited<
+          ReturnType<typeof getBoardSnapshotApiV1BoardsBoardIdSnapshotGet>
+        >,
+        TError,
+        TData
+      >
+    >;
+    request?: SecondParameter<typeof customFetch>;
+  },
+  queryClient?: QueryClient,
+): UseQueryResult<TData, TError> & {
+  queryKey: DataTag<QueryKey, TData, TError>;
+} {
+  const queryOptions =
+    getGetBoardSnapshotApiV1BoardsBoardIdSnapshotGetQueryOptions(
+      boardId,
+      options,
+    );
+
+  const query = useQuery(queryOptions, queryClient) as UseQueryResult<
+    TData,
+    TError
+  > & { queryKey: DataTag<QueryKey, TData, TError> };
+
+  return { ...query, queryKey: queryOptions.queryKey };
+}
+
 /**
  * Get a grouped snapshot across related boards.
 
@@ -1104,242 +1343,3 @@ export function useGetBoardGroupSnapshotApiV1BoardsBoardIdGroupSnapshotGet<
 
   return { ...query, queryKey: queryOptions.queryKey };
 }
-
-/**
- * Get a board snapshot view model.
- * @summary Get Board Snapshot
- */
-export type getBoardSnapshotApiV1BoardsBoardIdSnapshotGetResponse200 = {
-  data: BoardSnapshot;
-  status: 200;
-};
-
-export type getBoardSnapshotApiV1BoardsBoardIdSnapshotGetResponse422 = {
-  data: HTTPValidationError;
-  status: 422;
-};
-
-export type getBoardSnapshotApiV1BoardsBoardIdSnapshotGetResponseSuccess =
-  getBoardSnapshotApiV1BoardsBoardIdSnapshotGetResponse200 & {
-    headers: Headers;
-  };
-export type getBoardSnapshotApiV1BoardsBoardIdSnapshotGetResponseError =
-  getBoardSnapshotApiV1BoardsBoardIdSnapshotGetResponse422 & {
-    headers: Headers;
-  };
-
-export type getBoardSnapshotApiV1BoardsBoardIdSnapshotGetResponse =
-  | getBoardSnapshotApiV1BoardsBoardIdSnapshotGetResponseSuccess
-  | getBoardSnapshotApiV1BoardsBoardIdSnapshotGetResponseError;
-
-export const getGetBoardSnapshotApiV1BoardsBoardIdSnapshotGetUrl = (
-  boardId: string,
-) => {
-  return `/api/v1/boards/${boardId}/snapshot`;
-};
-
-export const getBoardSnapshotApiV1BoardsBoardIdSnapshotGet = async (
-  boardId: string,
-  options?: RequestInit,
-): Promise<getBoardSnapshotApiV1BoardsBoardIdSnapshotGetResponse> => {
-  return customFetch<getBoardSnapshotApiV1BoardsBoardIdSnapshotGetResponse>(
-    getGetBoardSnapshotApiV1BoardsBoardIdSnapshotGetUrl(boardId),
-    {
-      ...options,
-      method: "GET",
-    },
-  );
-};
-
-export const getGetBoardSnapshotApiV1BoardsBoardIdSnapshotGetQueryKey = (
-  boardId: string,
-) => {
-  return [`/api/v1/boards/${boardId}/snapshot`] as const;
-};
-
-export const getGetBoardSnapshotApiV1BoardsBoardIdSnapshotGetQueryOptions = <
-  TData = Awaited<
-    ReturnType<typeof getBoardSnapshotApiV1BoardsBoardIdSnapshotGet>
-  >,
-  TError = HTTPValidationError,
->(
-  boardId: string,
-  options?: {
-    query?: Partial<
-      UseQueryOptions<
-        Awaited<
-          ReturnType<typeof getBoardSnapshotApiV1BoardsBoardIdSnapshotGet>
-        >,
-        TError,
-        TData
-      >
-    >;
-    request?: SecondParameter<typeof customFetch>;
-  },
-) => {
-  const { query: queryOptions, request: requestOptions } = options ?? {};
-
-  const queryKey =
-    queryOptions?.queryKey ??
-    getGetBoardSnapshotApiV1BoardsBoardIdSnapshotGetQueryKey(boardId);
-
-  const queryFn: QueryFunction<
-    Awaited<ReturnType<typeof getBoardSnapshotApiV1BoardsBoardIdSnapshotGet>>
-  > = ({ signal }) =>
-    getBoardSnapshotApiV1BoardsBoardIdSnapshotGet(boardId, {
-      signal,
-      ...requestOptions,
-    });
-
-  return {
-    queryKey,
-    queryFn,
-    enabled: !!boardId,
-    ...queryOptions,
-  } as UseQueryOptions<
-    Awaited<ReturnType<typeof getBoardSnapshotApiV1BoardsBoardIdSnapshotGet>>,
-    TError,
-    TData
-  > & { queryKey: DataTag<QueryKey, TData, TError> };
-};
-
-export type GetBoardSnapshotApiV1BoardsBoardIdSnapshotGetQueryResult =
-  NonNullable<
-    Awaited<ReturnType<typeof getBoardSnapshotApiV1BoardsBoardIdSnapshotGet>>
-  >;
-export type GetBoardSnapshotApiV1BoardsBoardIdSnapshotGetQueryError =
-  HTTPValidationError;
-
-export function useGetBoardSnapshotApiV1BoardsBoardIdSnapshotGet<
-  TData = Awaited<
-    ReturnType<typeof getBoardSnapshotApiV1BoardsBoardIdSnapshotGet>
-  >,
-  TError = HTTPValidationError,
->(
-  boardId: string,
-  options: {
-    query: Partial<
-      UseQueryOptions<
-        Awaited<
-          ReturnType<typeof getBoardSnapshotApiV1BoardsBoardIdSnapshotGet>
-        >,
-        TError,
-        TData
-      >
-    > &
-      Pick<
-        DefinedInitialDataOptions<
-          Awaited<
-            ReturnType<typeof getBoardSnapshotApiV1BoardsBoardIdSnapshotGet>
-          >,
-          TError,
-          Awaited<
-            ReturnType<typeof getBoardSnapshotApiV1BoardsBoardIdSnapshotGet>
-          >
-        >,
-        "initialData"
-      >;
-    request?: SecondParameter<typeof customFetch>;
-  },
-  queryClient?: QueryClient,
-): DefinedUseQueryResult<TData, TError> & {
-  queryKey: DataTag<QueryKey, TData, TError>;
-};
-export function useGetBoardSnapshotApiV1BoardsBoardIdSnapshotGet<
-  TData = Awaited<
-    ReturnType<typeof getBoardSnapshotApiV1BoardsBoardIdSnapshotGet>
-  >,
-  TError = HTTPValidationError,
->(
-  boardId: string,
-  options?: {
-    query?: Partial<
-      UseQueryOptions<
-        Awaited<
-          ReturnType<typeof getBoardSnapshotApiV1BoardsBoardIdSnapshotGet>
-        >,
-        TError,
-        TData
-      >
-    > &
-      Pick<
-        UndefinedInitialDataOptions<
-          Awaited<
-            ReturnType<typeof getBoardSnapshotApiV1BoardsBoardIdSnapshotGet>
-          >,
-          TError,
-          Awaited<
-            ReturnType<typeof getBoardSnapshotApiV1BoardsBoardIdSnapshotGet>
-          >
-        >,
-        "initialData"
-      >;
-    request?: SecondParameter<typeof customFetch>;
-  },
-  queryClient?: QueryClient,
-): UseQueryResult<TData, TError> & {
-  queryKey: DataTag<QueryKey, TData, TError>;
-};
-export function useGetBoardSnapshotApiV1BoardsBoardIdSnapshotGet<
-  TData = Awaited<
-    ReturnType<typeof getBoardSnapshotApiV1BoardsBoardIdSnapshotGet>
-  >,
-  TError = HTTPValidationError,
->(
-  boardId: string,
-  options?: {
-    query?: Partial<
-      UseQueryOptions<
-        Awaited<
-          ReturnType<typeof getBoardSnapshotApiV1BoardsBoardIdSnapshotGet>
-        >,
-        TError,
-        TData
-      >
-    >;
-    request?: SecondParameter<typeof customFetch>;
-  },
-  queryClient?: QueryClient,
-): UseQueryResult<TData, TError> & {
-  queryKey: DataTag<QueryKey, TData, TError>;
-};
-/**
- * @summary Get Board Snapshot
- */
-
-export function useGetBoardSnapshotApiV1BoardsBoardIdSnapshotGet<
-  TData = Awaited<
-    ReturnType<typeof getBoardSnapshotApiV1BoardsBoardIdSnapshotGet>
-  >,
-  TError = HTTPValidationError,
->(
-  boardId: string,
-  options?: {
-    query?: Partial<
-      UseQueryOptions<
-        Awaited<
-          ReturnType<typeof getBoardSnapshotApiV1BoardsBoardIdSnapshotGet>
-        >,
-        TError,
-        TData
-      >
-    >;
-    request?: SecondParameter<typeof customFetch>;
-  },
-  queryClient?: QueryClient,
-): UseQueryResult<TData, TError> & {
-  queryKey: DataTag<QueryKey, TData, TError>;
-} {
-  const queryOptions =
-    getGetBoardSnapshotApiV1BoardsBoardIdSnapshotGetQueryOptions(
-      boardId,
-      options,
-    );
-
-  const query = useQuery(queryOptions, queryClient) as UseQueryResult<
-    TData,
-    TError
-  > & { queryKey: DataTag<QueryKey, TData, TError> };
-
-  return { ...query, queryKey: queryOptions.queryKey };
-}

frontend/src/api/generated/custom-fields/custom-fields.ts

@@ -0,0 +1,751 @@
+/**
+ * Generated by orval v8.3.0 🍺
+ * Do not edit manually.
+ * Mission Control API
+ * OpenAPI spec version: 0.1.0
+ */
+import { useMutation, useQuery } from "@tanstack/react-query";
+import type {
+  DataTag,
+  DefinedInitialDataOptions,
+  DefinedUseQueryResult,
+  MutationFunction,
+  QueryClient,
+  QueryFunction,
+  QueryKey,
+  UndefinedInitialDataOptions,
+  UseMutationOptions,
+  UseMutationResult,
+  UseQueryOptions,
+  UseQueryResult,
+} from "@tanstack/react-query";
+
+import type {
+  HTTPValidationError,
+  OkResponse,
+  TaskCustomFieldDefinitionCreate,
+  TaskCustomFieldDefinitionRead,
+  TaskCustomFieldDefinitionUpdate,
+} from ".././model";
+
+import { customFetch } from "../../mutator";
+
+type SecondParameter<T extends (...args: never) => unknown> = Parameters<T>[1];
+
+/**
+ * List task custom field definitions for the authenticated organization.
+ * @summary List Org Custom Fields
+ */
+export type listOrgCustomFieldsApiV1OrganizationsMeCustomFieldsGetResponse200 =
+  {
+    data: TaskCustomFieldDefinitionRead[];
+    status: 200;
+  };
+
+export type listOrgCustomFieldsApiV1OrganizationsMeCustomFieldsGetResponseSuccess =
+  listOrgCustomFieldsApiV1OrganizationsMeCustomFieldsGetResponse200 & {
+    headers: Headers;
+  };
+export type listOrgCustomFieldsApiV1OrganizationsMeCustomFieldsGetResponse =
+  listOrgCustomFieldsApiV1OrganizationsMeCustomFieldsGetResponseSuccess;
+
+export const getListOrgCustomFieldsApiV1OrganizationsMeCustomFieldsGetUrl =
+  () => {
+    return `/api/v1/organizations/me/custom-fields`;
+  };
+
+export const listOrgCustomFieldsApiV1OrganizationsMeCustomFieldsGet = async (
+  options?: RequestInit,
+): Promise<listOrgCustomFieldsApiV1OrganizationsMeCustomFieldsGetResponse> => {
+  return customFetch<listOrgCustomFieldsApiV1OrganizationsMeCustomFieldsGetResponse>(
+    getListOrgCustomFieldsApiV1OrganizationsMeCustomFieldsGetUrl(),
+    {
+      ...options,
+      method: "GET",
+    },
+  );
+};
+
+export const getListOrgCustomFieldsApiV1OrganizationsMeCustomFieldsGetQueryKey =
+  () => {
+    return [`/api/v1/organizations/me/custom-fields`] as const;
+  };
+
+export const getListOrgCustomFieldsApiV1OrganizationsMeCustomFieldsGetQueryOptions =
+  <
+    TData = Awaited<
+      ReturnType<typeof listOrgCustomFieldsApiV1OrganizationsMeCustomFieldsGet>
+    >,
+    TError = unknown,
+  >(options?: {
+    query?: Partial<
+      UseQueryOptions<
+        Awaited<
+          ReturnType<
+            typeof listOrgCustomFieldsApiV1OrganizationsMeCustomFieldsGet
+          >
+        >,
+        TError,
+        TData
+      >
+    >;
+    request?: SecondParameter<typeof customFetch>;
+  }) => {
+    const { query: queryOptions, request: requestOptions } = options ?? {};
+
+    const queryKey =
+      queryOptions?.queryKey ??
+      getListOrgCustomFieldsApiV1OrganizationsMeCustomFieldsGetQueryKey();
+
+    const queryFn: QueryFunction<
+      Awaited<
+        ReturnType<
+          typeof listOrgCustomFieldsApiV1OrganizationsMeCustomFieldsGet
+        >
+      >
+    > = ({ signal }) =>
+      listOrgCustomFieldsApiV1OrganizationsMeCustomFieldsGet({
+        signal,
+        ...requestOptions,
+      });
+
+    return { queryKey, queryFn, ...queryOptions } as UseQueryOptions<
+      Awaited<
+        ReturnType<
+          typeof listOrgCustomFieldsApiV1OrganizationsMeCustomFieldsGet
+        >
+      >,
+      TError,
+      TData
+    > & { queryKey: DataTag<QueryKey, TData, TError> };
+  };
+
+export type ListOrgCustomFieldsApiV1OrganizationsMeCustomFieldsGetQueryResult =
+  NonNullable<
+    Awaited<
+      ReturnType<typeof listOrgCustomFieldsApiV1OrganizationsMeCustomFieldsGet>
+    >
+  >;
+export type ListOrgCustomFieldsApiV1OrganizationsMeCustomFieldsGetQueryError =
+  unknown;
+
+export function useListOrgCustomFieldsApiV1OrganizationsMeCustomFieldsGet<
+  TData = Awaited<
+    ReturnType<typeof listOrgCustomFieldsApiV1OrganizationsMeCustomFieldsGet>
+  >,
+  TError = unknown,
+>(
+  options: {
+    query: Partial<
+      UseQueryOptions<
+        Awaited<
+          ReturnType<
+            typeof listOrgCustomFieldsApiV1OrganizationsMeCustomFieldsGet
+          >
+        >,
+        TError,
+        TData
+      >
+    > &
+      Pick<
+        DefinedInitialDataOptions<
+          Awaited<
+            ReturnType<
+              typeof listOrgCustomFieldsApiV1OrganizationsMeCustomFieldsGet
+            >
+          >,
+          TError,
+          Awaited<
+            ReturnType<
+              typeof listOrgCustomFieldsApiV1OrganizationsMeCustomFieldsGet
+            >
+          >
+        >,
+        "initialData"
+      >;
+    request?: SecondParameter<typeof customFetch>;
+  },
+  queryClient?: QueryClient,
+): DefinedUseQueryResult<TData, TError> & {
+  queryKey: DataTag<QueryKey, TData, TError>;
+};
+export function useListOrgCustomFieldsApiV1OrganizationsMeCustomFieldsGet<
+  TData = Awaited<
+    ReturnType<typeof listOrgCustomFieldsApiV1OrganizationsMeCustomFieldsGet>
+  >,
+  TError = unknown,
+>(
+  options?: {
+    query?: Partial<
+      UseQueryOptions<
+        Awaited<
+          ReturnType<
+            typeof listOrgCustomFieldsApiV1OrganizationsMeCustomFieldsGet
+          >
+        >,
+        TError,
+        TData
+      >
+    > &
+      Pick<
+        UndefinedInitialDataOptions<
+          Awaited<
+            ReturnType<
+              typeof listOrgCustomFieldsApiV1OrganizationsMeCustomFieldsGet
+            >
+          >,
+          TError,
+          Awaited<
+            ReturnType<
+              typeof listOrgCustomFieldsApiV1OrganizationsMeCustomFieldsGet
+            >
+          >
+        >,
+        "initialData"
+      >;
+    request?: SecondParameter<typeof customFetch>;
+  },
+  queryClient?: QueryClient,
+): UseQueryResult<TData, TError> & {
+  queryKey: DataTag<QueryKey, TData, TError>;
+};
+export function useListOrgCustomFieldsApiV1OrganizationsMeCustomFieldsGet<
+  TData = Awaited<
+    ReturnType<typeof listOrgCustomFieldsApiV1OrganizationsMeCustomFieldsGet>
+  >,
+  TError = unknown,
+>(
+  options?: {
+    query?: Partial<
+      UseQueryOptions<
+        Awaited<
+          ReturnType<
+            typeof listOrgCustomFieldsApiV1OrganizationsMeCustomFieldsGet
+          >
+        >,
+        TError,
+        TData
+      >
+    >;
+    request?: SecondParameter<typeof customFetch>;
+  },
+  queryClient?: QueryClient,
+): UseQueryResult<TData, TError> & {
+  queryKey: DataTag<QueryKey, TData, TError>;
+};
+/**
+ * @summary List Org Custom Fields
+ */
+
+export function useListOrgCustomFieldsApiV1OrganizationsMeCustomFieldsGet<
+  TData = Awaited<
+    ReturnType<typeof listOrgCustomFieldsApiV1OrganizationsMeCustomFieldsGet>
+  >,
+  TError = unknown,
+>(
+  options?: {
+    query?: Partial<
+      UseQueryOptions<
+        Awaited<
+          ReturnType<
+            typeof listOrgCustomFieldsApiV1OrganizationsMeCustomFieldsGet
+          >
+        >,
+        TError,
+        TData
+      >
+    >;
+    request?: SecondParameter<typeof customFetch>;
+  },
+  queryClient?: QueryClient,
+): UseQueryResult<TData, TError> & {
+  queryKey: DataTag<QueryKey, TData, TError>;
+} {
+  const queryOptions =
+    getListOrgCustomFieldsApiV1OrganizationsMeCustomFieldsGetQueryOptions(
+      options,
+    );
+
+  const query = useQuery(queryOptions, queryClient) as UseQueryResult<
+    TData,
+    TError
+  > & { queryKey: DataTag<QueryKey, TData, TError> };
+
+  return { ...query, queryKey: queryOptions.queryKey };
+}
+
+/**
+ * Create an organization-level task custom field definition.
+ * @summary Create Org Custom Field
+ */
+export type createOrgCustomFieldApiV1OrganizationsMeCustomFieldsPostResponse200 =
+  {
+    data: TaskCustomFieldDefinitionRead;
+    status: 200;
+  };
+
+export type createOrgCustomFieldApiV1OrganizationsMeCustomFieldsPostResponse422 =
+  {
+    data: HTTPValidationError;
+    status: 422;
+  };
+
+export type createOrgCustomFieldApiV1OrganizationsMeCustomFieldsPostResponseSuccess =
+  createOrgCustomFieldApiV1OrganizationsMeCustomFieldsPostResponse200 & {
+    headers: Headers;
+  };
+export type createOrgCustomFieldApiV1OrganizationsMeCustomFieldsPostResponseError =
+  createOrgCustomFieldApiV1OrganizationsMeCustomFieldsPostResponse422 & {
+    headers: Headers;
+  };
+
+export type createOrgCustomFieldApiV1OrganizationsMeCustomFieldsPostResponse =
+  | createOrgCustomFieldApiV1OrganizationsMeCustomFieldsPostResponseSuccess
+  | createOrgCustomFieldApiV1OrganizationsMeCustomFieldsPostResponseError;
+
+export const getCreateOrgCustomFieldApiV1OrganizationsMeCustomFieldsPostUrl =
+  () => {
+    return `/api/v1/organizations/me/custom-fields`;
+  };
+
+export const createOrgCustomFieldApiV1OrganizationsMeCustomFieldsPost = async (
+  taskCustomFieldDefinitionCreate: TaskCustomFieldDefinitionCreate,
+  options?: RequestInit,
+): Promise<createOrgCustomFieldApiV1OrganizationsMeCustomFieldsPostResponse> => {
+  return customFetch<createOrgCustomFieldApiV1OrganizationsMeCustomFieldsPostResponse>(
+    getCreateOrgCustomFieldApiV1OrganizationsMeCustomFieldsPostUrl(),
+    {
+      ...options,
+      method: "POST",
+      headers: { "Content-Type": "application/json", ...options?.headers },
+      body: JSON.stringify(taskCustomFieldDefinitionCreate),
+    },
+  );
+};
+
+export const getCreateOrgCustomFieldApiV1OrganizationsMeCustomFieldsPostMutationOptions =
+  <TError = HTTPValidationError, TContext = unknown>(options?: {
+    mutation?: UseMutationOptions<
+      Awaited<
+        ReturnType<
+          typeof createOrgCustomFieldApiV1OrganizationsMeCustomFieldsPost
+        >
+      >,
+      TError,
+      { data: TaskCustomFieldDefinitionCreate },
+      TContext
+    >;
+    request?: SecondParameter<typeof customFetch>;
+  }): UseMutationOptions<
+    Awaited<
+      ReturnType<
+        typeof createOrgCustomFieldApiV1OrganizationsMeCustomFieldsPost
+      >
+    >,
+    TError,
+    { data: TaskCustomFieldDefinitionCreate },
+    TContext
+  > => {
+    const mutationKey = [
+      "createOrgCustomFieldApiV1OrganizationsMeCustomFieldsPost",
+    ];
+    const { mutation: mutationOptions, request: requestOptions } = options
+      ? options.mutation &&
+        "mutationKey" in options.mutation &&
+        options.mutation.mutationKey
+        ? options
+        : { ...options, mutation: { ...options.mutation, mutationKey } }
+      : { mutation: { mutationKey }, request: undefined };
+
+    const mutationFn: MutationFunction<
+      Awaited<
+        ReturnType<
+          typeof createOrgCustomFieldApiV1OrganizationsMeCustomFieldsPost
+        >
+      >,
+      { data: TaskCustomFieldDefinitionCreate }
+    > = (props) => {
+      const { data } = props ?? {};
+
+      return createOrgCustomFieldApiV1OrganizationsMeCustomFieldsPost(
+        data,
+        requestOptions,
+      );
+    };
+
+    return { mutationFn, ...mutationOptions };
+  };
+
+export type CreateOrgCustomFieldApiV1OrganizationsMeCustomFieldsPostMutationResult =
+  NonNullable<
+    Awaited<
+      ReturnType<
+        typeof createOrgCustomFieldApiV1OrganizationsMeCustomFieldsPost
+      >
+    >
+  >;
+export type CreateOrgCustomFieldApiV1OrganizationsMeCustomFieldsPostMutationBody =
+  TaskCustomFieldDefinitionCreate;
+export type CreateOrgCustomFieldApiV1OrganizationsMeCustomFieldsPostMutationError =
+  HTTPValidationError;
+
+/**
+ * @summary Create Org Custom Field
+ */
+export const useCreateOrgCustomFieldApiV1OrganizationsMeCustomFieldsPost = <
+  TError = HTTPValidationError,
+  TContext = unknown,
+>(
+  options?: {
+    mutation?: UseMutationOptions<
+      Awaited<
+        ReturnType<
+          typeof createOrgCustomFieldApiV1OrganizationsMeCustomFieldsPost
+        >
+      >,
+      TError,
+      { data: TaskCustomFieldDefinitionCreate },
+      TContext
+    >;
+    request?: SecondParameter<typeof customFetch>;
+  },
+  queryClient?: QueryClient,
+): UseMutationResult<
+  Awaited<
+    ReturnType<typeof createOrgCustomFieldApiV1OrganizationsMeCustomFieldsPost>
+  >,
+  TError,
+  { data: TaskCustomFieldDefinitionCreate },
+  TContext
+> => {
+  return useMutation(
+    getCreateOrgCustomFieldApiV1OrganizationsMeCustomFieldsPostMutationOptions(
+      options,
+    ),
+    queryClient,
+  );
+};
+/**
+ * Update an organization-level task custom field definition.
+ * @summary Update Org Custom Field
+ */
+export type updateOrgCustomFieldApiV1OrganizationsMeCustomFieldsTaskCustomFieldDefinitionIdPatchResponse200 =
+  {
+    data: TaskCustomFieldDefinitionRead;
+    status: 200;
+  };
+
+export type updateOrgCustomFieldApiV1OrganizationsMeCustomFieldsTaskCustomFieldDefinitionIdPatchResponse422 =
+  {
+    data: HTTPValidationError;
+    status: 422;
+  };
+
+export type updateOrgCustomFieldApiV1OrganizationsMeCustomFieldsTaskCustomFieldDefinitionIdPatchResponseSuccess =
+  updateOrgCustomFieldApiV1OrganizationsMeCustomFieldsTaskCustomFieldDefinitionIdPatchResponse200 & {
+    headers: Headers;
+  };
+export type updateOrgCustomFieldApiV1OrganizationsMeCustomFieldsTaskCustomFieldDefinitionIdPatchResponseError =
+  updateOrgCustomFieldApiV1OrganizationsMeCustomFieldsTaskCustomFieldDefinitionIdPatchResponse422 & {
+    headers: Headers;
+  };
+
+export type updateOrgCustomFieldApiV1OrganizationsMeCustomFieldsTaskCustomFieldDefinitionIdPatchResponse =
+
+    | updateOrgCustomFieldApiV1OrganizationsMeCustomFieldsTaskCustomFieldDefinitionIdPatchResponseSuccess
+    | updateOrgCustomFieldApiV1OrganizationsMeCustomFieldsTaskCustomFieldDefinitionIdPatchResponseError;
+
+export const getUpdateOrgCustomFieldApiV1OrganizationsMeCustomFieldsTaskCustomFieldDefinitionIdPatchUrl =
+  (taskCustomFieldDefinitionId: string) => {
+    return `/api/v1/organizations/me/custom-fields/${taskCustomFieldDefinitionId}`;
+  };
+
+export const updateOrgCustomFieldApiV1OrganizationsMeCustomFieldsTaskCustomFieldDefinitionIdPatch =
+  async (
+    taskCustomFieldDefinitionId: string,
+    taskCustomFieldDefinitionUpdate: TaskCustomFieldDefinitionUpdate,
+    options?: RequestInit,
+  ): Promise<updateOrgCustomFieldApiV1OrganizationsMeCustomFieldsTaskCustomFieldDefinitionIdPatchResponse> => {
+    return customFetch<updateOrgCustomFieldApiV1OrganizationsMeCustomFieldsTaskCustomFieldDefinitionIdPatchResponse>(
+      getUpdateOrgCustomFieldApiV1OrganizationsMeCustomFieldsTaskCustomFieldDefinitionIdPatchUrl(
+        taskCustomFieldDefinitionId,
+      ),
+      {
+        ...options,
+        method: "PATCH",
+        headers: { "Content-Type": "application/json", ...options?.headers },
+        body: JSON.stringify(taskCustomFieldDefinitionUpdate),
+      },
+    );
+  };
+
+export const getUpdateOrgCustomFieldApiV1OrganizationsMeCustomFieldsTaskCustomFieldDefinitionIdPatchMutationOptions =
+  <TError = HTTPValidationError, TContext = unknown>(options?: {
+    mutation?: UseMutationOptions<
+      Awaited<
+        ReturnType<
+          typeof updateOrgCustomFieldApiV1OrganizationsMeCustomFieldsTaskCustomFieldDefinitionIdPatch
+        >
+      >,
+      TError,
+      {
+        taskCustomFieldDefinitionId: string;
+        data: TaskCustomFieldDefinitionUpdate;
+      },
+      TContext
+    >;
+    request?: SecondParameter<typeof customFetch>;
+  }): UseMutationOptions<
+    Awaited<
+      ReturnType<
+        typeof updateOrgCustomFieldApiV1OrganizationsMeCustomFieldsTaskCustomFieldDefinitionIdPatch
+      >
+    >,
+    TError,
+    {
+      taskCustomFieldDefinitionId: string;
+      data: TaskCustomFieldDefinitionUpdate;
+    },
+    TContext
+  > => {
+    const mutationKey = [
+      "updateOrgCustomFieldApiV1OrganizationsMeCustomFieldsTaskCustomFieldDefinitionIdPatch",
+    ];
+    const { mutation: mutationOptions, request: requestOptions } = options
+      ? options.mutation &&
+        "mutationKey" in options.mutation &&
+        options.mutation.mutationKey
+        ? options
+        : { ...options, mutation: { ...options.mutation, mutationKey } }
+      : { mutation: { mutationKey }, request: undefined };
+
+    const mutationFn: MutationFunction<
+      Awaited<
+        ReturnType<
+          typeof updateOrgCustomFieldApiV1OrganizationsMeCustomFieldsTaskCustomFieldDefinitionIdPatch
+        >
+      >,
+      {
+        taskCustomFieldDefinitionId: string;
+        data: TaskCustomFieldDefinitionUpdate;
+      }
+    > = (props) => {
+      const { taskCustomFieldDefinitionId, data } = props ?? {};
+
+      return updateOrgCustomFieldApiV1OrganizationsMeCustomFieldsTaskCustomFieldDefinitionIdPatch(
+        taskCustomFieldDefinitionId,
+        data,
+        requestOptions,
+      );
+    };
+
+    return { mutationFn, ...mutationOptions };
+  };
+
+export type UpdateOrgCustomFieldApiV1OrganizationsMeCustomFieldsTaskCustomFieldDefinitionIdPatchMutationResult =
+  NonNullable<
+    Awaited<
+      ReturnType<
+        typeof updateOrgCustomFieldApiV1OrganizationsMeCustomFieldsTaskCustomFieldDefinitionIdPatch
+      >
+    >
+  >;
+export type UpdateOrgCustomFieldApiV1OrganizationsMeCustomFieldsTaskCustomFieldDefinitionIdPatchMutationBody =
+  TaskCustomFieldDefinitionUpdate;
+export type UpdateOrgCustomFieldApiV1OrganizationsMeCustomFieldsTaskCustomFieldDefinitionIdPatchMutationError =
+  HTTPValidationError;
+
+/**
+ * @summary Update Org Custom Field
+ */
+export const useUpdateOrgCustomFieldApiV1OrganizationsMeCustomFieldsTaskCustomFieldDefinitionIdPatch =
+  <TError = HTTPValidationError, TContext = unknown>(
+    options?: {
+      mutation?: UseMutationOptions<
+        Awaited<
+          ReturnType<
+            typeof updateOrgCustomFieldApiV1OrganizationsMeCustomFieldsTaskCustomFieldDefinitionIdPatch
+          >
+        >,
+        TError,
+        {
+          taskCustomFieldDefinitionId: string;
+          data: TaskCustomFieldDefinitionUpdate;
+        },
+        TContext
+      >;
+      request?: SecondParameter<typeof customFetch>;
+    },
+    queryClient?: QueryClient,
+  ): UseMutationResult<
+    Awaited<
+      ReturnType<
+        typeof updateOrgCustomFieldApiV1OrganizationsMeCustomFieldsTaskCustomFieldDefinitionIdPatch
+      >
+    >,
+    TError,
+    {
+      taskCustomFieldDefinitionId: string;
+      data: TaskCustomFieldDefinitionUpdate;
+    },
+    TContext
+  > => {
+    return useMutation(
+      getUpdateOrgCustomFieldApiV1OrganizationsMeCustomFieldsTaskCustomFieldDefinitionIdPatchMutationOptions(
+        options,
+      ),
+      queryClient,
+    );
+  };
+/**
+ * Delete an org-level definition when it has no persisted task values.
+ * @summary Delete Org Custom Field
+ */
+export type deleteOrgCustomFieldApiV1OrganizationsMeCustomFieldsTaskCustomFieldDefinitionIdDeleteResponse200 =
+  {
+    data: OkResponse;
+    status: 200;
+  };
+
+export type deleteOrgCustomFieldApiV1OrganizationsMeCustomFieldsTaskCustomFieldDefinitionIdDeleteResponse422 =
+  {
+    data: HTTPValidationError;
+    status: 422;
+  };
+
+export type deleteOrgCustomFieldApiV1OrganizationsMeCustomFieldsTaskCustomFieldDefinitionIdDeleteResponseSuccess =
+  deleteOrgCustomFieldApiV1OrganizationsMeCustomFieldsTaskCustomFieldDefinitionIdDeleteResponse200 & {
+    headers: Headers;
+  };
+export type deleteOrgCustomFieldApiV1OrganizationsMeCustomFieldsTaskCustomFieldDefinitionIdDeleteResponseError =
+  deleteOrgCustomFieldApiV1OrganizationsMeCustomFieldsTaskCustomFieldDefinitionIdDeleteResponse422 & {
+    headers: Headers;
+  };
+
+export type deleteOrgCustomFieldApiV1OrganizationsMeCustomFieldsTaskCustomFieldDefinitionIdDeleteResponse =
+
+    | deleteOrgCustomFieldApiV1OrganizationsMeCustomFieldsTaskCustomFieldDefinitionIdDeleteResponseSuccess
+    | deleteOrgCustomFieldApiV1OrganizationsMeCustomFieldsTaskCustomFieldDefinitionIdDeleteResponseError;
+
+export const getDeleteOrgCustomFieldApiV1OrganizationsMeCustomFieldsTaskCustomFieldDefinitionIdDeleteUrl =
+  (taskCustomFieldDefinitionId: string) => {
+    return `/api/v1/organizations/me/custom-fields/${taskCustomFieldDefinitionId}`;
+  };
+
+export const deleteOrgCustomFieldApiV1OrganizationsMeCustomFieldsTaskCustomFieldDefinitionIdDelete =
+  async (
+    taskCustomFieldDefinitionId: string,
+    options?: RequestInit,
+  ): Promise<deleteOrgCustomFieldApiV1OrganizationsMeCustomFieldsTaskCustomFieldDefinitionIdDeleteResponse> => {
+    return customFetch<deleteOrgCustomFieldApiV1OrganizationsMeCustomFieldsTaskCustomFieldDefinitionIdDeleteResponse>(
+      getDeleteOrgCustomFieldApiV1OrganizationsMeCustomFieldsTaskCustomFieldDefinitionIdDeleteUrl(
+        taskCustomFieldDefinitionId,
+      ),
+      {
+        ...options,
+        method: "DELETE",
+      },
+    );
+  };
+
+export const getDeleteOrgCustomFieldApiV1OrganizationsMeCustomFieldsTaskCustomFieldDefinitionIdDeleteMutationOptions =
+  <TError = HTTPValidationError, TContext = unknown>(options?: {
+    mutation?: UseMutationOptions<
+      Awaited<
+        ReturnType<
+          typeof deleteOrgCustomFieldApiV1OrganizationsMeCustomFieldsTaskCustomFieldDefinitionIdDelete
+        >
+      >,
+      TError,
+      { taskCustomFieldDefinitionId: string },
+      TContext
+    >;
+    request?: SecondParameter<typeof customFetch>;
+  }): UseMutationOptions<
+    Awaited<
+      ReturnType<
+        typeof deleteOrgCustomFieldApiV1OrganizationsMeCustomFieldsTaskCustomFieldDefinitionIdDelete
+      >
+    >,
+    TError,
+    { taskCustomFieldDefinitionId: string },
+    TContext
+  > => {
+    const mutationKey = [
+      "deleteOrgCustomFieldApiV1OrganizationsMeCustomFieldsTaskCustomFieldDefinitionIdDelete",
+    ];
+    const { mutation: mutationOptions, request: requestOptions } = options
+      ? options.mutation &&
+        "mutationKey" in options.mutation &&
+        options.mutation.mutationKey
+        ? options
+        : { ...options, mutation: { ...options.mutation, mutationKey } }
+      : { mutation: { mutationKey }, request: undefined };
+
+    const mutationFn: MutationFunction<
+      Awaited<
+        ReturnType<
+          typeof deleteOrgCustomFieldApiV1OrganizationsMeCustomFieldsTaskCustomFieldDefinitionIdDelete
+        >
+      >,
+      { taskCustomFieldDefinitionId: string }
+    > = (props) => {
+      const { taskCustomFieldDefinitionId } = props ?? {};
+
+      return deleteOrgCustomFieldApiV1OrganizationsMeCustomFieldsTaskCustomFieldDefinitionIdDelete(
+        taskCustomFieldDefinitionId,
+        requestOptions,
+      );
+    };
+
+    return { mutationFn, ...mutationOptions };
+  };
+
+export type DeleteOrgCustomFieldApiV1OrganizationsMeCustomFieldsTaskCustomFieldDefinitionIdDeleteMutationResult =
+  NonNullable<
+    Awaited<
+      ReturnType<
+        typeof deleteOrgCustomFieldApiV1OrganizationsMeCustomFieldsTaskCustomFieldDefinitionIdDelete
+      >
+    >
+  >;
+
+export type DeleteOrgCustomFieldApiV1OrganizationsMeCustomFieldsTaskCustomFieldDefinitionIdDeleteMutationError =
+  HTTPValidationError;
+
+/**
+ * @summary Delete Org Custom Field
+ */
+export const useDeleteOrgCustomFieldApiV1OrganizationsMeCustomFieldsTaskCustomFieldDefinitionIdDelete =
+  <TError = HTTPValidationError, TContext = unknown>(
+    options?: {
+      mutation?: UseMutationOptions<
+        Awaited<
+          ReturnType<
+            typeof deleteOrgCustomFieldApiV1OrganizationsMeCustomFieldsTaskCustomFieldDefinitionIdDelete
+          >
+        >,
+        TError,
+        { taskCustomFieldDefinitionId: string },
+        TContext
+      >;
+      request?: SecondParameter<typeof customFetch>;
+    },
+    queryClient?: QueryClient,
+  ): UseMutationResult<
+    Awaited<
+      ReturnType<
+        typeof deleteOrgCustomFieldApiV1OrganizationsMeCustomFieldsTaskCustomFieldDefinitionIdDelete
+      >
+    >,
+    TError,
+    { taskCustomFieldDefinitionId: string },
+    TContext
+  > => {
+    return useMutation(
+      getDeleteOrgCustomFieldApiV1OrganizationsMeCustomFieldsTaskCustomFieldDefinitionIdDeleteMutationOptions(
+        options,
+      ),
+      queryClient,
+    );
+  };

frontend/src/api/generated/health/health.ts

@@ -0,0 +1,514 @@
+/**
+ * Generated by orval v8.3.0 🍺
+ * Do not edit manually.
+ * Mission Control API
+ * OpenAPI spec version: 0.1.0
+ */
+import { useQuery } from "@tanstack/react-query";
+import type {
+  DataTag,
+  DefinedInitialDataOptions,
+  DefinedUseQueryResult,
+  QueryClient,
+  QueryFunction,
+  QueryKey,
+  UndefinedInitialDataOptions,
+  UseQueryOptions,
+  UseQueryResult,
+} from "@tanstack/react-query";
+
+import type { HealthStatusResponse } from ".././model";
+
+import { customFetch } from "../../mutator";
+
+type SecondParameter<T extends (...args: never) => unknown> = Parameters<T>[1];
+
+/**
+ * Lightweight liveness probe endpoint.
+ * @summary Health Check
+ */
+export type healthHealthGetResponse200 = {
+  data: HealthStatusResponse;
+  status: 200;
+};
+
+export type healthHealthGetResponseSuccess = healthHealthGetResponse200 & {
+  headers: Headers;
+};
+export type healthHealthGetResponse = healthHealthGetResponseSuccess;
+
+export const getHealthHealthGetUrl = () => {
+  return `/health`;
+};
+
+export const healthHealthGet = async (
+  options?: RequestInit,
+): Promise<healthHealthGetResponse> => {
+  return customFetch<healthHealthGetResponse>(getHealthHealthGetUrl(), {
+    ...options,
+    method: "GET",
+  });
+};
+
+export const getHealthHealthGetQueryKey = () => {
+  return [`/health`] as const;
+};
+
+export const getHealthHealthGetQueryOptions = <
+  TData = Awaited<ReturnType<typeof healthHealthGet>>,
+  TError = unknown,
+>(options?: {
+  query?: Partial<
+    UseQueryOptions<Awaited<ReturnType<typeof healthHealthGet>>, TError, TData>
+  >;
+  request?: SecondParameter<typeof customFetch>;
+}) => {
+  const { query: queryOptions, request: requestOptions } = options ?? {};
+
+  const queryKey = queryOptions?.queryKey ?? getHealthHealthGetQueryKey();
+
+  const queryFn: QueryFunction<Awaited<ReturnType<typeof healthHealthGet>>> = ({
+    signal,
+  }) => healthHealthGet({ signal, ...requestOptions });
+
+  return { queryKey, queryFn, ...queryOptions } as UseQueryOptions<
+    Awaited<ReturnType<typeof healthHealthGet>>,
+    TError,
+    TData
+  > & { queryKey: DataTag<QueryKey, TData, TError> };
+};
+
+export type HealthHealthGetQueryResult = NonNullable<
+  Awaited<ReturnType<typeof healthHealthGet>>
+>;
+export type HealthHealthGetQueryError = unknown;
+
+export function useHealthHealthGet<
+  TData = Awaited<ReturnType<typeof healthHealthGet>>,
+  TError = unknown,
+>(
+  options: {
+    query: Partial<
+      UseQueryOptions<
+        Awaited<ReturnType<typeof healthHealthGet>>,
+        TError,
+        TData
+      >
+    > &
+      Pick<
+        DefinedInitialDataOptions<
+          Awaited<ReturnType<typeof healthHealthGet>>,
+          TError,
+          Awaited<ReturnType<typeof healthHealthGet>>
+        >,
+        "initialData"
+      >;
+    request?: SecondParameter<typeof customFetch>;
+  },
+  queryClient?: QueryClient,
+): DefinedUseQueryResult<TData, TError> & {
+  queryKey: DataTag<QueryKey, TData, TError>;
+};
+export function useHealthHealthGet<
+  TData = Awaited<ReturnType<typeof healthHealthGet>>,
+  TError = unknown,
+>(
+  options?: {
+    query?: Partial<
+      UseQueryOptions<
+        Awaited<ReturnType<typeof healthHealthGet>>,
+        TError,
+        TData
+      >
+    > &
+      Pick<
+        UndefinedInitialDataOptions<
+          Awaited<ReturnType<typeof healthHealthGet>>,
+          TError,
+          Awaited<ReturnType<typeof healthHealthGet>>
+        >,
+        "initialData"
+      >;
+    request?: SecondParameter<typeof customFetch>;
+  },
+  queryClient?: QueryClient,
+): UseQueryResult<TData, TError> & {
+  queryKey: DataTag<QueryKey, TData, TError>;
+};
+export function useHealthHealthGet<
+  TData = Awaited<ReturnType<typeof healthHealthGet>>,
+  TError = unknown,
+>(
+  options?: {
+    query?: Partial<
+      UseQueryOptions<
+        Awaited<ReturnType<typeof healthHealthGet>>,
+        TError,
+        TData
+      >
+    >;
+    request?: SecondParameter<typeof customFetch>;
+  },
+  queryClient?: QueryClient,
+): UseQueryResult<TData, TError> & {
+  queryKey: DataTag<QueryKey, TData, TError>;
+};
+/**
+ * @summary Health Check
+ */
+
+export function useHealthHealthGet<
+  TData = Awaited<ReturnType<typeof healthHealthGet>>,
+  TError = unknown,
+>(
+  options?: {
+    query?: Partial<
+      UseQueryOptions<
+        Awaited<ReturnType<typeof healthHealthGet>>,
+        TError,
+        TData
+      >
+    >;
+    request?: SecondParameter<typeof customFetch>;
+  },
+  queryClient?: QueryClient,
+): UseQueryResult<TData, TError> & {
+  queryKey: DataTag<QueryKey, TData, TError>;
+} {
+  const queryOptions = getHealthHealthGetQueryOptions(options);
+
+  const query = useQuery(queryOptions, queryClient) as UseQueryResult<
+    TData,
+    TError
+  > & { queryKey: DataTag<QueryKey, TData, TError> };
+
+  return { ...query, queryKey: queryOptions.queryKey };
+}
+
+/**
+ * Alias liveness probe endpoint for platform compatibility.
+ * @summary Health Alias Check
+ */
+export type healthzHealthzGetResponse200 = {
+  data: HealthStatusResponse;
+  status: 200;
+};
+
+export type healthzHealthzGetResponseSuccess = healthzHealthzGetResponse200 & {
+  headers: Headers;
+};
+export type healthzHealthzGetResponse = healthzHealthzGetResponseSuccess;
+
+export const getHealthzHealthzGetUrl = () => {
+  return `/healthz`;
+};
+
+export const healthzHealthzGet = async (
+  options?: RequestInit,
+): Promise<healthzHealthzGetResponse> => {
+  return customFetch<healthzHealthzGetResponse>(getHealthzHealthzGetUrl(), {
+    ...options,
+    method: "GET",
+  });
+};
+
+export const getHealthzHealthzGetQueryKey = () => {
+  return [`/healthz`] as const;
+};
+
+export const getHealthzHealthzGetQueryOptions = <
+  TData = Awaited<ReturnType<typeof healthzHealthzGet>>,
+  TError = unknown,
+>(options?: {
+  query?: Partial<
+    UseQueryOptions<
+      Awaited<ReturnType<typeof healthzHealthzGet>>,
+      TError,
+      TData
+    >
+  >;
+  request?: SecondParameter<typeof customFetch>;
+}) => {
+  const { query: queryOptions, request: requestOptions } = options ?? {};
+
+  const queryKey = queryOptions?.queryKey ?? getHealthzHealthzGetQueryKey();
+
+  const queryFn: QueryFunction<
+    Awaited<ReturnType<typeof healthzHealthzGet>>
+  > = ({ signal }) => healthzHealthzGet({ signal, ...requestOptions });
+
+  return { queryKey, queryFn, ...queryOptions } as UseQueryOptions<
+    Awaited<ReturnType<typeof healthzHealthzGet>>,
+    TError,
+    TData
+  > & { queryKey: DataTag<QueryKey, TData, TError> };
+};
+
+export type HealthzHealthzGetQueryResult = NonNullable<
+  Awaited<ReturnType<typeof healthzHealthzGet>>
+>;
+export type HealthzHealthzGetQueryError = unknown;
+
+export function useHealthzHealthzGet<
+  TData = Awaited<ReturnType<typeof healthzHealthzGet>>,
+  TError = unknown,
+>(
+  options: {
+    query: Partial<
+      UseQueryOptions<
+        Awaited<ReturnType<typeof healthzHealthzGet>>,
+        TError,
+        TData
+      >
+    > &
+      Pick<
+        DefinedInitialDataOptions<
+          Awaited<ReturnType<typeof healthzHealthzGet>>,
+          TError,
+          Awaited<ReturnType<typeof healthzHealthzGet>>
+        >,
+        "initialData"
+      >;
+    request?: SecondParameter<typeof customFetch>;
+  },
+  queryClient?: QueryClient,
+): DefinedUseQueryResult<TData, TError> & {
+  queryKey: DataTag<QueryKey, TData, TError>;
+};
+export function useHealthzHealthzGet<
+  TData = Awaited<ReturnType<typeof healthzHealthzGet>>,
+  TError = unknown,
+>(
+  options?: {
+    query?: Partial<
+      UseQueryOptions<
+        Awaited<ReturnType<typeof healthzHealthzGet>>,
+        TError,
+        TData
+      >
+    > &
+      Pick<
+        UndefinedInitialDataOptions<
+          Awaited<ReturnType<typeof healthzHealthzGet>>,
+          TError,
+          Awaited<ReturnType<typeof healthzHealthzGet>>
+        >,
+        "initialData"
+      >;
+    request?: SecondParameter<typeof customFetch>;
+  },
+  queryClient?: QueryClient,
+): UseQueryResult<TData, TError> & {
+  queryKey: DataTag<QueryKey, TData, TError>;
+};
+export function useHealthzHealthzGet<
+  TData = Awaited<ReturnType<typeof healthzHealthzGet>>,
+  TError = unknown,
+>(
+  options?: {
+    query?: Partial<
+      UseQueryOptions<
+        Awaited<ReturnType<typeof healthzHealthzGet>>,
+        TError,
+        TData
+      >
+    >;
+    request?: SecondParameter<typeof customFetch>;
+  },
+  queryClient?: QueryClient,
+): UseQueryResult<TData, TError> & {
+  queryKey: DataTag<QueryKey, TData, TError>;
+};
+/**
+ * @summary Health Alias Check
+ */
+
+export function useHealthzHealthzGet<
+  TData = Awaited<ReturnType<typeof healthzHealthzGet>>,
+  TError = unknown,
+>(
+  options?: {
+    query?: Partial<
+      UseQueryOptions<
+        Awaited<ReturnType<typeof healthzHealthzGet>>,
+        TError,
+        TData
+      >
+    >;
+    request?: SecondParameter<typeof customFetch>;
+  },
+  queryClient?: QueryClient,
+): UseQueryResult<TData, TError> & {
+  queryKey: DataTag<QueryKey, TData, TError>;
+} {
+  const queryOptions = getHealthzHealthzGetQueryOptions(options);
+
+  const query = useQuery(queryOptions, queryClient) as UseQueryResult<
+    TData,
+    TError
+  > & { queryKey: DataTag<QueryKey, TData, TError> };
+
+  return { ...query, queryKey: queryOptions.queryKey };
+}
+
+/**
+ * Readiness probe endpoint for service orchestration checks.
+ * @summary Readiness Check
+ */
+export type readyzReadyzGetResponse200 = {
+  data: HealthStatusResponse;
+  status: 200;
+};
+
+export type readyzReadyzGetResponseSuccess = readyzReadyzGetResponse200 & {
+  headers: Headers;
+};
+export type readyzReadyzGetResponse = readyzReadyzGetResponseSuccess;
+
+export const getReadyzReadyzGetUrl = () => {
+  return `/readyz`;
+};
+
+export const readyzReadyzGet = async (
+  options?: RequestInit,
+): Promise<readyzReadyzGetResponse> => {
+  return customFetch<readyzReadyzGetResponse>(getReadyzReadyzGetUrl(), {
+    ...options,
+    method: "GET",
+  });
+};
+
+export const getReadyzReadyzGetQueryKey = () => {
+  return [`/readyz`] as const;
+};
+
+export const getReadyzReadyzGetQueryOptions = <
+  TData = Awaited<ReturnType<typeof readyzReadyzGet>>,
+  TError = unknown,
+>(options?: {
+  query?: Partial<
+    UseQueryOptions<Awaited<ReturnType<typeof readyzReadyzGet>>, TError, TData>
+  >;
+  request?: SecondParameter<typeof customFetch>;
+}) => {
+  const { query: queryOptions, request: requestOptions } = options ?? {};
+
+  const queryKey = queryOptions?.queryKey ?? getReadyzReadyzGetQueryKey();
+
+  const queryFn: QueryFunction<Awaited<ReturnType<typeof readyzReadyzGet>>> = ({
+    signal,
+  }) => readyzReadyzGet({ signal, ...requestOptions });
+
+  return { queryKey, queryFn, ...queryOptions } as UseQueryOptions<
+    Awaited<ReturnType<typeof readyzReadyzGet>>,
+    TError,
+    TData
+  > & { queryKey: DataTag<QueryKey, TData, TError> };
+};
+
+export type ReadyzReadyzGetQueryResult = NonNullable<
+  Awaited<ReturnType<typeof readyzReadyzGet>>
+>;
+export type ReadyzReadyzGetQueryError = unknown;
+
+export function useReadyzReadyzGet<
+  TData = Awaited<ReturnType<typeof readyzReadyzGet>>,
+  TError = unknown,
+>(
+  options: {
+    query: Partial<
+      UseQueryOptions<
+        Awaited<ReturnType<typeof readyzReadyzGet>>,
+        TError,
+        TData
+      >
+    > &
+      Pick<
+        DefinedInitialDataOptions<
+          Awaited<ReturnType<typeof readyzReadyzGet>>,
+          TError,
+          Awaited<ReturnType<typeof readyzReadyzGet>>
+        >,
+        "initialData"
+      >;
+    request?: SecondParameter<typeof customFetch>;
+  },
+  queryClient?: QueryClient,
+): DefinedUseQueryResult<TData, TError> & {
+  queryKey: DataTag<QueryKey, TData, TError>;
+};
+export function useReadyzReadyzGet<
+  TData = Awaited<ReturnType<typeof readyzReadyzGet>>,
+  TError = unknown,
+>(
+  options?: {
+    query?: Partial<
+      UseQueryOptions<
+        Awaited<ReturnType<typeof readyzReadyzGet>>,
+        TError,
+        TData
+      >
+    > &
+      Pick<
+        UndefinedInitialDataOptions<
+          Awaited<ReturnType<typeof readyzReadyzGet>>,
+          TError,
+          Awaited<ReturnType<typeof readyzReadyzGet>>
+        >,
+        "initialData"
+      >;
+    request?: SecondParameter<typeof customFetch>;
+  },
+  queryClient?: QueryClient,
+): UseQueryResult<TData, TError> & {
+  queryKey: DataTag<QueryKey, TData, TError>;
+};
+export function useReadyzReadyzGet<
+  TData = Awaited<ReturnType<typeof readyzReadyzGet>>,
+  TError = unknown,
+>(
+  options?: {
+    query?: Partial<
+      UseQueryOptions<
+        Awaited<ReturnType<typeof readyzReadyzGet>>,
+        TError,
+        TData
+      >
+    >;
+    request?: SecondParameter<typeof customFetch>;
+  },
+  queryClient?: QueryClient,
+): UseQueryResult<TData, TError> & {
+  queryKey: DataTag<QueryKey, TData, TError>;
+};
+/**
+ * @summary Readiness Check
+ */
+
+export function useReadyzReadyzGet<
+  TData = Awaited<ReturnType<typeof readyzReadyzGet>>,
+  TError = unknown,
+>(
+  options?: {
+    query?: Partial<
+      UseQueryOptions<
+        Awaited<ReturnType<typeof readyzReadyzGet>>,
+        TError,
+        TData
+      >
+    >;
+    request?: SecondParameter<typeof customFetch>;
+  },
+  queryClient?: QueryClient,
+): UseQueryResult<TData, TError> & {
+  queryKey: DataTag<QueryKey, TData, TError>;
+} {
+  const queryOptions = getReadyzReadyzGetQueryOptions(options);
+
+  const query = useQuery(queryOptions, queryClient) as UseQueryResult<
+    TData,
+    TError
+  > & { queryKey: DataTag<QueryKey, TData, TError> };
+
+  return { ...query, queryKey: queryOptions.queryKey };
+}

frontend/src/api/generated/model/activityEventRead.ts

@@ -9,10 +9,10 @@
  * Serialized activity event payload returned by activity endpoints.
  */
 export interface ActivityEventRead {
-  agent_id: string | null;
-  created_at: string;
-  event_type: string;
   id: string;
+  event_type: string;
   message: string | null;
+  agent_id: string | null;
   task_id: string | null;
+  created_at: string;
 }

frontend/src/api/generated/model/activityTaskCommentFeedItemRead.ts

@@ -9,14 +9,14 @@
  * Denormalized task-comment feed item enriched with task and board fields.
  */
 export interface ActivityTaskCommentFeedItemRead {
+  id: string;
+  created_at: string;
+  message: string | null;
   agent_id: string | null;
   agent_name?: string | null;
   agent_role?: string | null;
-  board_id: string;
-  board_name: string;
-  created_at: string;
-  id: string;
-  message: string | null;
   task_id: string;
   task_title: string;
+  board_id: string;
+  board_name: string;
 }

frontend/src/api/generated/model/agentCreate.ts

@@ -11,12 +11,21 @@ import type { AgentCreateIdentityProfile } from "./agentCreateIdentityProfile";
  * Payload for creating a new agent.
  */
 export interface AgentCreate {
+  /** Board id that scopes this agent. Omit only when policy allows global agents. */
   board_id?: string | null;
-  heartbeat_config?: AgentCreateHeartbeatConfig;
+  /**
-  identity_profile?: AgentCreateIdentityProfile;
+   * Human-readable agent display name.
-  identity_template?: string | null;
+   * @minLength 1
-  /** @minLength 1 */
+   */
   name: string;
-  soul_template?: string | null;
+  /** Current lifecycle state used by coordinator logic. */
   status?: string;
+  /** Runtime heartbeat behavior overrides for this agent. */
+  heartbeat_config?: AgentCreateHeartbeatConfig;
+  /** Optional profile hints used by routing and policy checks. */
+  identity_profile?: AgentCreateIdentityProfile;
+  /** Template that helps define initial intent and behavior. */
+  identity_template?: string | null;
+  /** Template representing deeper agent instructions. */
+  soul_template?: string | null;
 }

frontend/src/api/generated/model/agentCreateHeartbeatConfig.ts

@@ -5,4 +5,7 @@
  * OpenAPI spec version: 0.1.0
  */
 
+/**
+ * Runtime heartbeat behavior overrides for this agent.
+ */
 export type AgentCreateHeartbeatConfig = { [key: string]: unknown } | null;

frontend/src/api/generated/model/agentCreateIdentityProfile.ts

@@ -5,4 +5,7 @@
  * OpenAPI spec version: 0.1.0
  */
 
+/**
+ * Optional profile hints used by routing and policy checks.
+ */
 export type AgentCreateIdentityProfile = { [key: string]: unknown } | null;

frontend/src/api/generated/model/agentHeartbeat.ts

@@ -9,5 +9,6 @@
  * Heartbeat status payload sent by agents.
  */
 export interface AgentHeartbeat {
+  /** Agent health status string. */
   status?: string | null;
 }

frontend/src/api/generated/model/agentHeartbeatCreate.ts

@@ -9,8 +9,13 @@
  * Heartbeat payload used to create an agent lazily.
  */
 export interface AgentHeartbeatCreate {
-  board_id?: string | null;
+  /** Agent health status string. */
-  /** @minLength 1 */
-  name: string;
   status?: string | null;
+  /**
+   * Display name assigned during first heartbeat bootstrap.
+   * @minLength 1
+   */
+  name: string;
+  /** Optional board context for bootstrap. */
+  board_id?: string | null;
 }

frontend/src/api/generated/model/agentNudge.ts

@@ -9,6 +9,9 @@
  * Nudge message payload for pinging an agent.
  */
 export interface AgentNudge {
-  /** @minLength 1 */
+  /**
+   * Short message to direct an agent toward immediate attention.
+   * @minLength 1
+   */
   message: string;
 }

frontend/src/api/generated/model/agentRead.ts

@@ -11,20 +11,37 @@ import type { AgentReadIdentityProfile } from "./agentReadIdentityProfile";
  * Public agent representation returned by the API.
  */
 export interface AgentRead {
+  /** Board id that scopes this agent. Omit only when policy allows global agents. */
   board_id?: string | null;
-  created_at: string;
+  /**
-  gateway_id: string;
+   * Human-readable agent display name.
-  heartbeat_config?: AgentReadHeartbeatConfig;
+   * @minLength 1
-  id: string;
+   */
-  identity_profile?: AgentReadIdentityProfile;
-  identity_template?: string | null;
-  is_board_lead?: boolean;
-  is_gateway_main?: boolean;
-  last_seen_at: string | null;
-  /** @minLength 1 */
   name: string;
-  openclaw_session_id?: string | null;
+  /** Current lifecycle state used by coordinator logic. */
-  soul_template?: string | null;
   status?: string;
+  /** Runtime heartbeat behavior overrides for this agent. */
+  heartbeat_config?: AgentReadHeartbeatConfig;
+  /** Optional profile hints used by routing and policy checks. */
+  identity_profile?: AgentReadIdentityProfile;
+  /** Template that helps define initial intent and behavior. */
+  identity_template?: string | null;
+  /** Template representing deeper agent instructions. */
+  soul_template?: string | null;
+  /** Agent UUID. */
+  id: string;
+  /** Gateway UUID that manages this agent. */
+  gateway_id: string;
+  /** Whether this agent is the board lead. */
+  is_board_lead?: boolean;
+  /** Whether this agent is the primary gateway agent. */
+  is_gateway_main?: boolean;
+  /** Optional openclaw session token. */
+  openclaw_session_id?: string | null;
+  /** Last heartbeat timestamp. */
+  last_seen_at?: string | null;
+  /** Creation timestamp. */
+  created_at: string;
+  /** Last update timestamp. */
   updated_at: string;
 }

frontend/src/api/generated/model/agentReadHeartbeatConfig.ts

@@ -5,4 +5,7 @@
  * OpenAPI spec version: 0.1.0
  */
 
+/**
+ * Runtime heartbeat behavior overrides for this agent.
+ */
 export type AgentReadHeartbeatConfig = { [key: string]: unknown } | null;

frontend/src/api/generated/model/agentReadIdentityProfile.ts

@@ -5,4 +5,7 @@
  * OpenAPI spec version: 0.1.0
  */
 
+/**
+ * Optional profile hints used by routing and policy checks.
+ */
 export type AgentReadIdentityProfile = { [key: string]: unknown } | null;

frontend/src/api/generated/model/agentUpdate.ts

@@ -11,12 +11,20 @@ import type { AgentUpdateIdentityProfile } from "./agentUpdateIdentityProfile";
  * Payload for patching an existing agent.
  */
 export interface AgentUpdate {
+  /** Optional new board assignment. */
   board_id?: string | null;
-  heartbeat_config?: AgentUpdateHeartbeatConfig;
+  /** Whether this agent is treated as the board gateway main. */
-  identity_profile?: AgentUpdateIdentityProfile;
-  identity_template?: string | null;
   is_gateway_main?: boolean | null;
+  /** Optional replacement display name. */
   name?: string | null;
-  soul_template?: string | null;
+  /** Optional replacement lifecycle status. */
   status?: string | null;
+  /** Optional heartbeat policy override. */
+  heartbeat_config?: AgentUpdateHeartbeatConfig;
+  /** Optional identity profile update values. */
+  identity_profile?: AgentUpdateIdentityProfile;
+  /** Optional replacement identity template. */
+  identity_template?: string | null;
+  /** Optional replacement soul template. */
+  soul_template?: string | null;
 }

frontend/src/api/generated/model/agentUpdateHeartbeatConfig.ts

@@ -5,4 +5,7 @@
  * OpenAPI spec version: 0.1.0
  */
 
+/**
+ * Optional heartbeat policy override.
+ */
 export type AgentUpdateHeartbeatConfig = { [key: string]: unknown } | null;

frontend/src/api/generated/model/agentUpdateIdentityProfile.ts

@@ -5,4 +5,7 @@
  * OpenAPI spec version: 0.1.0
  */
 
+/**
+ * Optional identity profile update values.
+ */
 export type AgentUpdateIdentityProfile = { [key: string]: unknown } | null;

frontend/src/api/generated/model/approvalCreate.ts

@@ -13,16 +13,16 @@ import type { ApprovalCreateStatus } from "./approvalCreateStatus";
  */
 export interface ApprovalCreate {
   action_type: string;
-  agent_id?: string | null;
+  task_id?: string | null;
+  task_ids?: string[];
+  payload?: ApprovalCreatePayload;
   /**
    * @minimum 0
    * @maximum 100
    */
   confidence: number;
-  lead_reasoning?: string | null;
-  payload?: ApprovalCreatePayload;
   rubric_scores?: ApprovalCreateRubricScores;
   status?: ApprovalCreateStatus;
-  task_id?: string | null;
+  agent_id?: string | null;
-  task_ids?: string[];
+  lead_reasoning?: string | null;
 }

frontend/src/api/generated/model/approvalRead.ts

@@ -13,20 +13,20 @@ import type { ApprovalReadStatus } from "./approvalReadStatus";
  */
 export interface ApprovalRead {
   action_type: string;
-  agent_id?: string | null;
+  task_id?: string | null;
-  board_id: string;
+  task_ids?: string[];
+  payload?: ApprovalReadPayload;
   /**
    * @minimum 0
    * @maximum 100
    */
   confidence: number;
-  created_at: string;
-  id: string;
-  payload?: ApprovalReadPayload;
-  resolved_at?: string | null;
   rubric_scores?: ApprovalReadRubricScores;
   status?: ApprovalReadStatus;
-  task_id?: string | null;
+  id: string;
-  task_ids?: string[];
+  board_id: string;
   task_titles?: string[];
+  agent_id?: string | null;
+  created_at: string;
+  resolved_at?: string | null;
 }

frontend/src/api/generated/model/blockedTaskDetail.ts

@@ -9,6 +9,6 @@
  * Error detail payload listing blocking dependency task identifiers.
  */
 export interface BlockedTaskDetail {
-  blocked_by_task_ids?: string[];
   message: string;
+  blocked_by_task_ids?: string[];
 }

frontend/src/api/generated/model/boardCreate.ts

@@ -10,21 +10,21 @@ import type { BoardCreateSuccessMetrics } from "./boardCreateSuccessMetrics";
  * Payload for creating a board.
  */
 export interface BoardCreate {
-  block_status_changes_with_pending_approval?: boolean;
+  name: string;
-  board_group_id?: string | null;
+  slug: string;
-  board_type?: string;
   description: string;
   gateway_id?: string | null;
-  goal_confirmed?: boolean;
+  board_group_id?: string | null;
-  goal_source?: string | null;
+  board_type?: string;
-  /** @minimum 0 */
-  max_agents?: number;
-  name: string;
   objective?: string | null;
-  only_lead_can_change_status?: boolean;
-  require_approval_for_done?: boolean;
-  require_review_before_done?: boolean;
-  slug: string;
   success_metrics?: BoardCreateSuccessMetrics;
   target_date?: string | null;
+  goal_confirmed?: boolean;
+  goal_source?: string | null;
+  require_approval_for_done?: boolean;
+  require_review_before_done?: boolean;
+  block_status_changes_with_pending_approval?: boolean;
+  only_lead_can_change_status?: boolean;
+  /** @minimum 0 */
+  max_agents?: number;
 }

frontend/src/api/generated/model/boardGroupCreate.ts

@@ -9,7 +9,7 @@
  * Payload for creating a board group.
  */
 export interface BoardGroupCreate {
-  description?: string | null;
   name: string;
   slug: string;
+  description?: string | null;
 }

frontend/src/api/generated/model/boardGroupHeartbeatApply.ts

@@ -11,5 +11,4 @@
 export interface BoardGroupHeartbeatApply {
   every: string;
   include_board_leads?: boolean;
-  target?: string | null;
 }

frontend/src/api/generated/model/boardGroupHeartbeatApplyResult.ts

@@ -11,7 +11,7 @@ import type { BoardGroupHeartbeatApplyResultRequested } from "./boardGroupHeartb
  */
 export interface BoardGroupHeartbeatApplyResult {
   board_group_id: string;
-  failed_agent_ids: string[];
   requested: BoardGroupHeartbeatApplyResultRequested;
   updated_agent_ids: string[];
+  failed_agent_ids: string[];
 }

frontend/src/api/generated/model/boardGroupMemoryCreate.ts

@@ -11,6 +11,6 @@
 export interface BoardGroupMemoryCreate {
   /** @minLength 1 */
   content: string;
-  source?: string | null;
   tags?: string[] | null;
+  source?: string | null;
 }

frontend/src/api/generated/model/boardGroupMemoryRead.ts

@@ -9,11 +9,11 @@
  * Serialized board-group memory entry returned from read endpoints.
  */
 export interface BoardGroupMemoryRead {
+  id: string;
   board_group_id: string;
   content: string;
-  created_at: string;
-  id: string;
-  is_chat?: boolean;
-  source?: string | null;
   tags?: string[] | null;
+  source?: string | null;
+  is_chat?: boolean;
+  created_at: string;
 }

frontend/src/api/generated/model/boardGroupRead.ts

@@ -9,11 +9,11 @@
  * Board-group payload returned from read endpoints.
  */
 export interface BoardGroupRead {
-  created_at: string;
+  name: string;
+  slug: string;
   description?: string | null;
   id: string;
-  name: string;
   organization_id: string;
-  slug: string;
+  created_at: string;
   updated_at: string;
 }

frontend/src/api/generated/model/boardGroupSnapshot.ts

@@ -11,6 +11,6 @@ import type { BoardGroupRead } from "./boardGroupRead";
  * Top-level board-group snapshot response payload.
  */
 export interface BoardGroupSnapshot {
-  boards?: BoardGroupBoardSnapshot[];
   group?: BoardGroupRead | null;
+  boards?: BoardGroupBoardSnapshot[];
 }

frontend/src/api/generated/model/boardGroupTaskSummary.ts

@@ -10,17 +10,17 @@ import type { TagRef } from "./tagRef";
  * Task summary row used inside board-group snapshot responses.
  */
 export interface BoardGroupTaskSummary {
-  assigned_agent_id?: string | null;
+  id: string;
-  assignee?: string | null;
   board_id: string;
   board_name: string;
-  created_at: string;
-  due_at?: string | null;
-  id: string;
-  in_progress_at?: string | null;
-  priority: string;
-  status: string;
-  tags?: TagRef[];
   title: string;
+  status: string;
+  priority: string;
+  assigned_agent_id?: string | null;
+  assignee?: string | null;
+  due_at?: string | null;
+  in_progress_at?: string | null;
+  tags?: TagRef[];
+  created_at: string;
   updated_at: string;
 }

frontend/src/api/generated/model/boardGroupUpdate.ts

@@ -9,7 +9,7 @@
  * Payload for partial board-group updates.
  */
 export interface BoardGroupUpdate {
-  description?: string | null;
   name?: string | null;
   slug?: string | null;
+  description?: string | null;
 }

frontend/src/api/generated/model/boardMemoryCreate.ts

@@ -11,6 +11,6 @@
 export interface BoardMemoryCreate {
   /** @minLength 1 */
   content: string;
-  source?: string | null;
   tags?: string[] | null;
+  source?: string | null;
 }

frontend/src/api/generated/model/boardMemoryRead.ts

@@ -9,11 +9,11 @@
  * Serialized board memory entry returned from read endpoints.
  */
 export interface BoardMemoryRead {
+  id: string;
   board_id: string;
   content: string;
-  created_at: string;
-  id: string;
-  is_chat?: boolean;
-  source?: string | null;
   tags?: string[] | null;
+  source?: string | null;
+  is_chat?: boolean;
+  created_at: string;
 }

frontend/src/api/generated/model/boardOnboardingAgentComplete.ts

@@ -13,10 +13,10 @@ import type { BoardOnboardingUserProfile } from "./boardOnboardingUserProfile";
  */
 export interface BoardOnboardingAgentComplete {
   board_type: string;
-  lead_agent?: BoardOnboardingLeadAgentDraft | null;
   objective?: string | null;
-  status: "complete";
   success_metrics?: BoardOnboardingAgentCompleteSuccessMetrics;
   target_date?: string | null;
+  status: "complete";
   user_profile?: BoardOnboardingUserProfile | null;
+  lead_agent?: BoardOnboardingLeadAgentDraft | null;
 }

frontend/src/api/generated/model/boardOnboardingAgentQuestion.ts

@@ -10,8 +10,8 @@ import type { BoardOnboardingQuestionOption } from "./boardOnboardingQuestionOpt
  * Question payload emitted by the onboarding assistant.
  */
 export interface BoardOnboardingAgentQuestion {
-  /** @minItems 1 */
-  options: BoardOnboardingQuestionOption[];
   /** @minLength 1 */
   question: string;
+  /** @minItems 1 */
+  options: BoardOnboardingQuestionOption[];
 }

frontend/src/api/generated/model/boardOnboardingLeadAgentDraft.ts

@@ -10,11 +10,11 @@ import type { BoardOnboardingLeadAgentDraftIdentityProfile } from "./boardOnboar
  * Editable lead-agent draft configuration.
  */
 export interface BoardOnboardingLeadAgentDraft {
-  autonomy_level?: "ask_first" | "balanced" | "autonomous" | null;
-  custom_instructions?: string | null;
-  identity_profile?: BoardOnboardingLeadAgentDraftIdentityProfile;
   name?: string | null;
+  identity_profile?: BoardOnboardingLeadAgentDraftIdentityProfile;
+  autonomy_level?: "ask_first" | "balanced" | "autonomous" | null;
+  verbosity?: "concise" | "balanced" | "detailed" | null;
   output_format?: "bullets" | "mixed" | "narrative" | null;
   update_cadence?: "asap" | "hourly" | "daily" | "weekly" | null;
-  verbosity?: "concise" | "balanced" | "detailed" | null;
+  custom_instructions?: string | null;
 }

frontend/src/api/generated/model/boardOnboardingRead.ts

@@ -11,12 +11,12 @@ import type { BoardOnboardingReadMessages } from "./boardOnboardingReadMessages"
  * Stored onboarding session state returned by API endpoints.
  */
 export interface BoardOnboardingRead {
-  board_id: string;
-  created_at: string;
-  draft_goal?: BoardOnboardingAgentComplete | null;
   id: string;
-  messages?: BoardOnboardingReadMessages;
+  board_id: string;
   session_key: string;
   status: string;
+  messages?: BoardOnboardingReadMessages;
+  draft_goal?: BoardOnboardingAgentComplete | null;
+  created_at: string;
   updated_at: string;
 }

frontend/src/api/generated/model/boardOnboardingUserProfile.ts

@@ -9,9 +9,9 @@
  * User-profile preferences gathered during onboarding.
  */
 export interface BoardOnboardingUserProfile {
-  context?: string | null;
-  notes?: string | null;
   preferred_name?: string | null;
   pronouns?: string | null;
   timezone?: string | null;
+  notes?: string | null;
+  context?: string | null;
 }

frontend/src/api/generated/model/boardRead.ts

@@ -10,25 +10,25 @@ import type { BoardReadSuccessMetrics } from "./boardReadSuccessMetrics";
  * Board payload returned from read endpoints.
  */
 export interface BoardRead {
-  block_status_changes_with_pending_approval?: boolean;
+  name: string;
-  board_group_id?: string | null;
+  slug: string;
-  board_type?: string;
-  created_at: string;
   description: string;
   gateway_id?: string | null;
-  goal_confirmed?: boolean;
+  board_group_id?: string | null;
-  goal_source?: string | null;
+  board_type?: string;
-  id: string;
-  /** @minimum 0 */
-  max_agents?: number;
-  name: string;
   objective?: string | null;
-  only_lead_can_change_status?: boolean;
-  organization_id: string;
-  require_approval_for_done?: boolean;
-  require_review_before_done?: boolean;
-  slug: string;
   success_metrics?: BoardReadSuccessMetrics;
   target_date?: string | null;
+  goal_confirmed?: boolean;
+  goal_source?: string | null;
+  require_approval_for_done?: boolean;
+  require_review_before_done?: boolean;
+  block_status_changes_with_pending_approval?: boolean;
+  only_lead_can_change_status?: boolean;
+  /** @minimum 0 */
+  max_agents?: number;
+  id: string;
+  organization_id: string;
+  created_at: string;
   updated_at: string;
 }

frontend/src/api/generated/model/boardSnapshot.ts

@@ -14,10 +14,10 @@ import type { TaskCardRead } from "./taskCardRead";
  * Aggregated board payload used by board snapshot endpoints.
  */
 export interface BoardSnapshot {
+  board: BoardRead;
+  tasks: TaskCardRead[];
   agents: AgentRead[];
   approvals: ApprovalRead[];
-  board: BoardRead;
   chat_messages: BoardMemoryRead[];
   pending_approvals_count?: number;
-  tasks: TaskCardRead[];
 }

frontend/src/api/generated/model/boardUpdate.ts

@@ -10,20 +10,20 @@ import type { BoardUpdateSuccessMetrics } from "./boardUpdateSuccessMetrics";
  * Payload for partial board updates.
  */
 export interface BoardUpdate {
-  block_status_changes_with_pending_approval?: boolean | null;
+  name?: string | null;
-  board_group_id?: string | null;
+  slug?: string | null;
-  board_type?: string | null;
   description?: string | null;
   gateway_id?: string | null;
-  goal_confirmed?: boolean | null;
+  board_group_id?: string | null;
-  goal_source?: string | null;
+  board_type?: string | null;
-  max_agents?: number | null;
-  name?: string | null;
   objective?: string | null;
-  only_lead_can_change_status?: boolean | null;
-  require_approval_for_done?: boolean | null;
-  require_review_before_done?: boolean | null;
-  slug?: string | null;
   success_metrics?: BoardUpdateSuccessMetrics;
   target_date?: string | null;
+  goal_confirmed?: boolean | null;
+  goal_source?: string | null;
+  require_approval_for_done?: boolean | null;
+  require_review_before_done?: boolean | null;
+  block_status_changes_with_pending_approval?: boolean | null;
+  only_lead_can_change_status?: boolean | null;
+  max_agents?: number | null;
 }

frontend/src/api/generated/model/boardWebhookCreate.ts

@@ -12,4 +12,5 @@ export interface BoardWebhookCreate {
   /** @minLength 1 */
   description: string;
   enabled?: boolean;
+  agent_id?: string | null;
 }

frontend/src/api/generated/model/boardWebhookIngestResponse.ts

@@ -9,8 +9,8 @@
  * Response payload for inbound webhook ingestion.
  */
 export interface BoardWebhookIngestResponse {
-  board_id: string;
   ok?: boolean;
-  payload_id: string;
+  board_id: string;
   webhook_id: string;
+  payload_id: string;
 }

frontend/src/api/generated/model/boardWebhookPayloadRead.ts

@@ -11,12 +11,12 @@ import type { BoardWebhookPayloadReadPayload } from "./boardWebhookPayloadReadPa
  * Serialized stored webhook payload.
  */
 export interface BoardWebhookPayloadRead {
-  board_id: string;
-  content_type?: string | null;
-  headers?: BoardWebhookPayloadReadHeaders;
   id: string;
-  payload?: BoardWebhookPayloadReadPayload;
+  board_id: string;
-  received_at: string;
-  source_ip?: string | null;
   webhook_id: string;
+  payload?: BoardWebhookPayloadReadPayload;
+  headers?: BoardWebhookPayloadReadHeaders;
+  source_ip?: string | null;
+  content_type?: string | null;
+  received_at: string;
 }

frontend/src/api/generated/model/boardWebhookRead.ts

@@ -9,12 +9,13 @@
  * Serialized board webhook configuration.
  */
 export interface BoardWebhookRead {
+  id: string;
   board_id: string;
-  created_at: string;
+  agent_id?: string | null;
   description: string;
   enabled: boolean;
   endpoint_path: string;
   endpoint_url?: string | null;
-  id: string;
+  created_at: string;
   updated_at: string;
 }

frontend/src/api/generated/model/boardWebhookUpdate.ts

@@ -11,4 +11,5 @@
 export interface BoardWebhookUpdate {
   description?: string | null;
   enabled?: boolean | null;
+  agent_id?: string | null;
 }

frontend/src/api/generated/model/dashboardKpis.ts

@@ -10,7 +10,7 @@
  */
 export interface DashboardKpis {
   active_agents: number;
+  tasks_in_progress: number;
   error_rate_pct: number;
   median_cycle_time_hours_7d: number | null;
-  tasks_in_progress: number;
 }

frontend/src/api/generated/model/dashboardMetrics.ts

@@ -13,11 +13,11 @@ import type { DashboardWipSeriesSet } from "./dashboardWipSeriesSet";
  * Complete dashboard metrics response payload.
  */
 export interface DashboardMetrics {
-  cycle_time: DashboardSeriesSet;
+  range: DashboardMetricsRange;
-  error_rate: DashboardSeriesSet;
   generated_at: string;
   kpis: DashboardKpis;
-  range: DashboardMetricsRange;
   throughput: DashboardSeriesSet;
+  cycle_time: DashboardSeriesSet;
+  error_rate: DashboardSeriesSet;
   wip: DashboardWipSeriesSet;
 }

frontend/src/api/generated/model/dashboardRangeSeries.ts

@@ -12,7 +12,7 @@ import type { DashboardSeriesPoint } from "./dashboardSeriesPoint";
  * Series payload for a single range/bucket combination.
  */
 export interface DashboardRangeSeries {
+  range: DashboardRangeSeriesRange;
   bucket: DashboardRangeSeriesBucket;
   points: DashboardSeriesPoint[];
-  range: DashboardRangeSeriesRange;
 }

frontend/src/api/generated/model/dashboardSeriesSet.ts

@@ -10,6 +10,6 @@ import type { DashboardRangeSeries } from "./dashboardRangeSeries";
  * Primary vs comparison pair for generic series metrics.
  */
 export interface DashboardSeriesSet {
-  comparison: DashboardRangeSeries;
   primary: DashboardRangeSeries;
+  comparison: DashboardRangeSeries;
 }

frontend/src/api/generated/model/dashboardWipPoint.ts

@@ -9,9 +9,9 @@
  * Work-in-progress point split by task status buckets.
  */
 export interface DashboardWipPoint {
-  done: number;
-  in_progress: number;
-  inbox: number;
   period: string;
+  inbox: number;
+  in_progress: number;
   review: number;
+  done: number;
 }

frontend/src/api/generated/model/dashboardWipRangeSeries.ts

@@ -12,7 +12,7 @@ import type { DashboardWipRangeSeriesRange } from "./dashboardWipRangeSeriesRang
  * WIP series payload for a single range/bucket combination.
  */
 export interface DashboardWipRangeSeries {
+  range: DashboardWipRangeSeriesRange;
   bucket: DashboardWipRangeSeriesBucket;
   points: DashboardWipPoint[];
-  range: DashboardWipRangeSeriesRange;
 }

frontend/src/api/generated/model/dashboardWipSeriesSet.ts

@@ -10,6 +10,6 @@ import type { DashboardWipRangeSeries } from "./dashboardWipRangeSeries";
  * Primary vs comparison pair for WIP status series metrics.
  */
 export interface DashboardWipSeriesSet {
-  comparison: DashboardWipRangeSeries;
   primary: DashboardWipRangeSeries;
+  comparison: DashboardWipRangeSeries;
 }

frontend/src/api/generated/model/gatewayCommandsResponse.ts

@@ -9,7 +9,7 @@
  * Gateway command catalog and protocol metadata.
  */
 export interface GatewayCommandsResponse {
-  events: string[];
-  methods: string[];
   protocol_version: number;
+  methods: string[];
+  events: string[];
 }

frontend/src/api/generated/model/gatewayCreate.ts

@@ -10,7 +10,7 @@
  */
 export interface GatewayCreate {
   name: string;
-  token?: string | null;
   url: string;
   workspace_root: string;
+  token?: string | null;
 }

frontend/src/api/generated/model/gatewayLeadBroadcastBoardResult.ts

@@ -9,9 +9,14 @@
  * Per-board result entry for a lead broadcast operation.
  */
 export interface GatewayLeadBroadcastBoardResult {
+  /** Target board id for this result. */
   board_id: string;
-  error?: string | null;
+  /** Resolved lead agent id for the target board. */
   lead_agent_id?: string | null;
+  /** Resolved lead agent display name. */
   lead_agent_name?: string | null;
+  /** Whether this board delivery succeeded. */
   ok?: boolean;
+  /** Failure reason if this board failed. */
+  error?: string | null;
 }

frontend/src/api/generated/model/gatewayLeadBroadcastRequest.ts

@@ -10,11 +10,19 @@ import type { GatewayLeadBroadcastRequestKind } from "./gatewayLeadBroadcastRequ
  * Request payload for broadcasting a message to multiple board leads.
  */
 export interface GatewayLeadBroadcastRequest {
-  board_ids?: string[] | null;
+  /** Broadcast intent. `question` asks for responses; `handoff` requests transfer. */
-  /** @minLength 1 */
-  content: string;
-  correlation_id?: string | null;
   kind?: GatewayLeadBroadcastRequestKind;
-  reply_source?: string | null;
+  /** Optional correlation token shared with downstream handlers. */
+  correlation_id?: string | null;
+  /**
+   * Message content distributed to selected board leads.
+   * @minLength 1
+   */
+  content: string;
+  /** Optional explicit list of board IDs; omit for lead-scoped defaults. */
+  board_ids?: string[] | null;
+  /** Tags required by reply templates when each lead responds. */
   reply_tags?: string[];
+  /** Reply destination key for broadcast responses. */
+  reply_source?: string | null;
 }

frontend/src/api/generated/model/gatewayLeadBroadcastRequestKind.ts

@@ -5,6 +5,9 @@
  * OpenAPI spec version: 0.1.0
  */
 
+/**
+ * Broadcast intent. `question` asks for responses; `handoff` requests transfer.
+ */
 export type GatewayLeadBroadcastRequestKind =
   (typeof GatewayLeadBroadcastRequestKind)[keyof typeof GatewayLeadBroadcastRequestKind];
 

frontend/src/api/generated/model/gatewayLeadBroadcastResponse.ts

@@ -10,8 +10,11 @@ import type { GatewayLeadBroadcastBoardResult } from "./gatewayLeadBroadcastBoar
  * Aggregate response for a lead broadcast operation.
  */
 export interface GatewayLeadBroadcastResponse {
-  failed?: number;
+  /** Whether broadcast execution succeeded. */
   ok?: boolean;
-  results?: GatewayLeadBroadcastBoardResult[];
+  /** Number of boards successfully messaged. */
   sent?: number;
+  /** Number of boards that failed messaging. */
+  failed?: number;
+  results?: GatewayLeadBroadcastBoardResult[];
 }

frontend/src/api/generated/model/gatewayLeadMessageRequest.ts

@@ -10,10 +10,17 @@ import type { GatewayLeadMessageRequestKind } from "./gatewayLeadMessageRequestK
  * Request payload for sending a message to a board lead agent.
  */
 export interface GatewayLeadMessageRequest {
-  /** @minLength 1 */
+  /** Routing mode for lead messages. */
-  content: string;
-  correlation_id?: string | null;
   kind?: GatewayLeadMessageRequestKind;
-  reply_source?: string | null;
+  /** Optional correlation token shared across upstream and downstream systems. */
+  correlation_id?: string | null;
+  /**
+   * Human-readable body sent to lead agents.
+   * @minLength 1
+   */
+  content: string;
+  /** Tags required by reply templates when the lead responds. */
   reply_tags?: string[];
+  /** Reply destination key for the orchestrator. */
+  reply_source?: string | null;
 }

frontend/src/api/generated/model/gatewayLeadMessageRequestKind.ts

@@ -5,6 +5,9 @@
  * OpenAPI spec version: 0.1.0
  */
 
+/**
+ * Routing mode for lead messages.
+ */
 export type GatewayLeadMessageRequestKind =
   (typeof GatewayLeadMessageRequestKind)[keyof typeof GatewayLeadMessageRequestKind];
 

frontend/src/api/generated/model/gatewayLeadMessageResponse.ts

@@ -9,9 +9,14 @@
  * Response payload for a lead-message dispatch attempt.
  */
 export interface GatewayLeadMessageResponse {
-  board_id: string;
+  /** Whether dispatch was accepted. */
-  lead_agent_id?: string | null;
-  lead_agent_name?: string | null;
-  lead_created?: boolean;
   ok?: boolean;
+  /** Board receiving the message. */
+  board_id: string;
+  /** Resolved lead agent id when present. */
+  lead_agent_id?: string | null;
+  /** Resolved lead agent display name. */
+  lead_agent_name?: string | null;
+  /** Whether a lead fallback actor was created during routing. */
+  lead_created?: boolean;
 }

frontend/src/api/generated/model/gatewayMainAskUserRequest.ts

@@ -9,10 +9,17 @@
  * Request payload for asking the end user via a main gateway agent.
  */
 export interface GatewayMainAskUserRequest {
-  /** @minLength 1 */
+  /** Optional correlation token for tracing request/response flow. */
-  content: string;
   correlation_id?: string | null;
+  /**
+   * Prompt that should be asked to the human.
+   * @minLength 1
+   */
+  content: string;
+  /** Optional preferred messaging channel. */
   preferred_channel?: string | null;
-  reply_source?: string | null;
+  /** Tags required for routing the user response. */
   reply_tags?: string[];
+  /** Reply destination key for user confirmation loops. */
+  reply_source?: string | null;
 }

frontend/src/api/generated/model/gatewayMainAskUserResponse.ts

@@ -9,8 +9,12 @@
  * Response payload for user-question dispatch via gateway main agent.
  */
 export interface GatewayMainAskUserResponse {
-  board_id: string;
+  /** Whether ask-user dispatch was accepted. */
-  main_agent_id?: string | null;
-  main_agent_name?: string | null;
   ok?: boolean;
+  /** Board context used for the request. */
+  board_id: string;
+  /** Resolved main agent id handling the ask. */
+  main_agent_id?: string | null;
+  /** Resolved main agent display name. */
+  main_agent_name?: string | null;
 }

frontend/src/api/generated/model/gatewayRead.ts

@@ -9,12 +9,12 @@
  * Gateway payload returned from read endpoints.
  */
 export interface GatewayRead {
-  created_at: string;
-  id: string;
   name: string;
-  organization_id: string;
-  token?: string | null;
-  updated_at: string;
   url: string;
   workspace_root: string;
+  id: string;
+  organization_id: string;
+  token?: string | null;
+  created_at: string;
+  updated_at: string;
 }

frontend/src/api/generated/model/gatewaySessionsResponse.ts

@@ -9,6 +9,6 @@
  * Gateway sessions list response payload.
  */
 export interface GatewaySessionsResponse {
-  main_session?: unknown | null;
   sessions: unknown[];
+  main_session?: unknown | null;
 }

frontend/src/api/generated/model/gatewayTemplatesSyncResult.ts

@@ -10,11 +10,11 @@ import type { GatewayTemplatesSyncError } from "./gatewayTemplatesSyncError";
  * Summary payload returned by gateway template sync endpoints.
  */
 export interface GatewayTemplatesSyncResult {
-  agents_skipped: number;
-  agents_updated: number;
-  errors?: GatewayTemplatesSyncError[];
   gateway_id: string;
   include_main: boolean;
-  main_updated: boolean;
   reset_sessions: boolean;
+  agents_updated: number;
+  agents_skipped: number;
+  main_updated: boolean;
+  errors?: GatewayTemplatesSyncError[];
 }

frontend/src/api/generated/model/gatewayUpdate.ts

@@ -10,7 +10,7 @@
  */
 export interface GatewayUpdate {
   name?: string | null;
-  token?: string | null;
   url?: string | null;
+  token?: string | null;
   workspace_root?: string | null;
 }

frontend/src/api/generated/model/gatewaysStatusResponse.ts

@@ -10,10 +10,10 @@
  */
 export interface GatewaysStatusResponse {
   connected: boolean;
-  error?: string | null;
   gateway_url: string;
+  sessions_count?: number | null;
+  sessions?: unknown[] | null;
   main_session?: unknown | null;
   main_session_error?: string | null;
-  sessions?: unknown[] | null;
+  error?: string | null;
-  sessions_count?: number | null;
 }

frontend/src/api/generated/model/healthStatusResponse.ts

@@ -0,0 +1,14 @@
+/**
+ * Generated by orval v8.3.0 🍺
+ * Do not edit manually.
+ * Mission Control API
+ * OpenAPI spec version: 0.1.0
+ */
+
+/**
+ * Standard payload for service liveness/readiness checks.
+ */
+export interface HealthStatusResponse {
+  /** Indicates whether the probe check succeeded. */
+  ok: boolean;
+}

frontend/src/api/generated/model/index.ts

@@ -112,6 +112,7 @@ export * from "./getBoardGroupSnapshotApiV1BoardsBoardIdGroupSnapshotGetParams";
 export * from "./getGatewaySessionApiV1GatewaysSessionsSessionIdGetParams";
 export * from "./getSessionHistoryApiV1GatewaysSessionsSessionIdHistoryGetParams";
 export * from "./healthHealthGet200";
+export * from "./healthStatusResponse";
 export * from "./healthzHealthzGet200";
 export * from "./hTTPValidationError";
 export * from "./installMarketplaceSkillApiV1SkillsMarketplaceSkillIdInstallPostParams";
@@ -156,10 +157,14 @@ export * from "./listTaskCommentsApiV1AgentBoardsBoardIdTasksTaskIdCommentsGetPa
 export * from "./listTaskCommentsApiV1BoardsBoardIdTasksTaskIdCommentsGetParams";
 export * from "./listTasksApiV1AgentBoardsBoardIdTasksGetParams";
 export * from "./listTasksApiV1BoardsBoardIdTasksGetParams";
+export * from "./lLMErrorResponse";
+export * from "./lLMErrorResponseDetail";
 export * from "./marketplaceSkillActionResponse";
 export * from "./marketplaceSkillCardRead";
+export * from "./marketplaceSkillCardReadMetadata";
 export * from "./marketplaceSkillCreate";
 export * from "./marketplaceSkillRead";
+export * from "./marketplaceSkillReadMetadata";
 export * from "./okResponse";
 export * from "./organizationActiveUpdate";
 export * from "./organizationBoardAccessRead";
@@ -178,7 +183,9 @@ export * from "./readyzReadyzGet200";
 export * from "./searchApiV1SoulsDirectorySearchGetParams";
 export * from "./sendGatewaySessionMessageApiV1GatewaysSessionsSessionIdMessagePostParams";
 export * from "./skillPackCreate";
+export * from "./skillPackCreateMetadata";
 export * from "./skillPackRead";
+export * from "./skillPackReadMetadata";
 export * from "./skillPackSyncResponse";
 export * from "./soulsDirectoryMarkdownResponse";
 export * from "./soulsDirectorySearchResponse";

frontend/src/api/generated/model/lLMErrorResponse.ts

@@ -0,0 +1,21 @@
+/**
+ * Generated by orval v8.3.0 🍺
+ * Do not edit manually.
+ * Mission Control API
+ * OpenAPI spec version: 0.1.0
+ */
+import type { LLMErrorResponseDetail } from "./lLMErrorResponseDetail";
+
+/**
+ * Standardized LLM-facing error payload used by API contracts.
+ */
+export interface LLMErrorResponse {
+  /** Error payload. Agents should rely on `code` when present and default to `message` for fallback display. */
+  detail: LLMErrorResponseDetail;
+  /** Request correlation identifier injected by middleware. */
+  request_id?: string | null;
+  /** Optional machine-readable error code. */
+  code?: string | null;
+  /** Whether a client should retry the call after remediating transient conditions. */
+  retryable?: boolean | null;
+}

frontend/src/api/generated/model/lLMErrorResponseDetail.ts

@@ -0,0 +1,14 @@
+/**
+ * Generated by orval v8.3.0 🍺
+ * Do not edit manually.
+ * Mission Control API
+ * OpenAPI spec version: 0.1.0
+ */
+
+/**
+ * Error payload. Agents should rely on `code` when present and default to `message` for fallback display.
+ */
+export type LLMErrorResponseDetail =
+  | string
+  | { [key: string]: unknown }
+  | unknown[];

frontend/src/api/generated/model/limitOffsetPageTypeVarCustomizedActivityEventRead.ts

@@ -8,10 +8,10 @@ import type { ActivityEventRead } from "./activityEventRead";
 
 export interface LimitOffsetPageTypeVarCustomizedActivityEventRead {
   items: ActivityEventRead[];
+  /** @minimum 0 */
+  total: number;
   /** @minimum 1 */
   limit: number;
   /** @minimum 0 */
   offset: number;
-  /** @minimum 0 */
-  total: number;
 }

frontend/src/api/generated/model/limitOffsetPageTypeVarCustomizedActivityTaskCommentFeedItemRead.ts

@@ -8,10 +8,10 @@ import type { ActivityTaskCommentFeedItemRead } from "./activityTaskCommentFeedI
 
 export interface LimitOffsetPageTypeVarCustomizedActivityTaskCommentFeedItemRead {
   items: ActivityTaskCommentFeedItemRead[];
+  /** @minimum 0 */
+  total: number;
   /** @minimum 1 */
   limit: number;
   /** @minimum 0 */
   offset: number;
-  /** @minimum 0 */
-  total: number;
 }

frontend/src/api/generated/model/limitOffsetPageTypeVarCustomizedAgentRead.ts

@@ -8,10 +8,10 @@ import type { AgentRead } from "./agentRead";
 
 export interface LimitOffsetPageTypeVarCustomizedAgentRead {
   items: AgentRead[];
+  /** @minimum 0 */
+  total: number;
   /** @minimum 1 */
   limit: number;
   /** @minimum 0 */
   offset: number;
-  /** @minimum 0 */
-  total: number;
 }

frontend/src/api/generated/model/limitOffsetPageTypeVarCustomizedApprovalRead.ts

@@ -8,10 +8,10 @@ import type { ApprovalRead } from "./approvalRead";
 
 export interface LimitOffsetPageTypeVarCustomizedApprovalRead {
   items: ApprovalRead[];
+  /** @minimum 0 */
+  total: number;
   /** @minimum 1 */
   limit: number;
   /** @minimum 0 */
   offset: number;
-  /** @minimum 0 */
-  total: number;
 }

frontend/src/api/generated/model/limitOffsetPageTypeVarCustomizedBoardGroupMemoryRead.ts

@@ -8,10 +8,10 @@ import type { BoardGroupMemoryRead } from "./boardGroupMemoryRead";
 
 export interface LimitOffsetPageTypeVarCustomizedBoardGroupMemoryRead {
   items: BoardGroupMemoryRead[];
+  /** @minimum 0 */
+  total: number;
   /** @minimum 1 */
   limit: number;
   /** @minimum 0 */
   offset: number;
-  /** @minimum 0 */
-  total: number;
 }

frontend/src/api/generated/model/limitOffsetPageTypeVarCustomizedBoardGroupRead.ts

@@ -8,10 +8,10 @@ import type { BoardGroupRead } from "./boardGroupRead";
 
 export interface LimitOffsetPageTypeVarCustomizedBoardGroupRead {
   items: BoardGroupRead[];
+  /** @minimum 0 */
+  total: number;
   /** @minimum 1 */
   limit: number;
   /** @minimum 0 */
   offset: number;
-  /** @minimum 0 */
-  total: number;
 }

frontend/src/api/generated/model/limitOffsetPageTypeVarCustomizedBoardMemoryRead.ts

@@ -8,10 +8,10 @@ import type { BoardMemoryRead } from "./boardMemoryRead";
 
 export interface LimitOffsetPageTypeVarCustomizedBoardMemoryRead {
   items: BoardMemoryRead[];
+  /** @minimum 0 */
+  total: number;
   /** @minimum 1 */
   limit: number;
   /** @minimum 0 */
   offset: number;
-  /** @minimum 0 */
-  total: number;
 }

frontend/src/api/generated/model/limitOffsetPageTypeVarCustomizedBoardRead.ts

@@ -8,10 +8,10 @@ import type { BoardRead } from "./boardRead";
 
 export interface LimitOffsetPageTypeVarCustomizedBoardRead {
   items: BoardRead[];
+  /** @minimum 0 */
+  total: number;
   /** @minimum 1 */
   limit: number;
   /** @minimum 0 */
   offset: number;
-  /** @minimum 0 */
-  total: number;
 }

frontend/src/api/generated/model/limitOffsetPageTypeVarCustomizedBoardWebhookPayloadRead.ts

@@ -8,10 +8,10 @@ import type { BoardWebhookPayloadRead } from "./boardWebhookPayloadRead";
 
 export interface LimitOffsetPageTypeVarCustomizedBoardWebhookPayloadRead {
   items: BoardWebhookPayloadRead[];
+  /** @minimum 0 */
+  total: number;
   /** @minimum 1 */
   limit: number;
   /** @minimum 0 */
   offset: number;
-  /** @minimum 0 */
-  total: number;
 }

frontend/src/api/generated/model/limitOffsetPageTypeVarCustomizedBoardWebhookRead.ts

@@ -8,10 +8,10 @@ import type { BoardWebhookRead } from "./boardWebhookRead";
 
 export interface LimitOffsetPageTypeVarCustomizedBoardWebhookRead {
   items: BoardWebhookRead[];
+  /** @minimum 0 */
+  total: number;
   /** @minimum 1 */
   limit: number;
   /** @minimum 0 */
   offset: number;
-  /** @minimum 0 */
-  total: number;
 }

frontend/src/api/generated/model/limitOffsetPageTypeVarCustomizedGatewayRead.ts

@@ -8,10 +8,10 @@ import type { GatewayRead } from "./gatewayRead";
 
 export interface LimitOffsetPageTypeVarCustomizedGatewayRead {
   items: GatewayRead[];
+  /** @minimum 0 */
+  total: number;
   /** @minimum 1 */
   limit: number;
   /** @minimum 0 */
   offset: number;
-  /** @minimum 0 */
-  total: number;
 }

frontend/src/api/generated/model/limitOffsetPageTypeVarCustomizedOrganizationInviteRead.ts

@@ -8,10 +8,10 @@ import type { OrganizationInviteRead } from "./organizationInviteRead";
 
 export interface LimitOffsetPageTypeVarCustomizedOrganizationInviteRead {
   items: OrganizationInviteRead[];
+  /** @minimum 0 */
+  total: number;
   /** @minimum 1 */
   limit: number;
   /** @minimum 0 */
   offset: number;
-  /** @minimum 0 */
-  total: number;
 }

frontend/src/api/generated/model/limitOffsetPageTypeVarCustomizedOrganizationMemberRead.ts

@@ -8,10 +8,10 @@ import type { OrganizationMemberRead } from "./organizationMemberRead";
 
 export interface LimitOffsetPageTypeVarCustomizedOrganizationMemberRead {
   items: OrganizationMemberRead[];
+  /** @minimum 0 */
+  total: number;
   /** @minimum 1 */
   limit: number;
   /** @minimum 0 */
   offset: number;
-  /** @minimum 0 */
-  total: number;
 }

frontend/src/api/generated/model/limitOffsetPageTypeVarCustomizedTagRead.ts

@@ -8,10 +8,10 @@ import type { TagRead } from "./tagRead";
 
 export interface LimitOffsetPageTypeVarCustomizedTagRead {
   items: TagRead[];
+  /** @minimum 0 */
+  total: number;
   /** @minimum 1 */
   limit: number;
   /** @minimum 0 */
   offset: number;
-  /** @minimum 0 */
-  total: number;
 }

frontend/src/api/generated/model/limitOffsetPageTypeVarCustomizedTaskCommentRead.ts

@@ -8,10 +8,10 @@ import type { TaskCommentRead } from "./taskCommentRead";
 
 export interface LimitOffsetPageTypeVarCustomizedTaskCommentRead {
   items: TaskCommentRead[];
+  /** @minimum 0 */
+  total: number;
   /** @minimum 1 */
   limit: number;
   /** @minimum 0 */
   offset: number;
-  /** @minimum 0 */
-  total: number;
 }