@k2b/cloud 0.37.0 → 0.39.0

package/src/_internal/panel-cookie.ts

@@ -0,0 +1,39 @@
+export const PANEL_COOKIE = "cloud_panel";
+export const PANEL_MIN_WIDTH_REM = 20;
+export const PANEL_MAX_WIDTH_REM = 36;
+
+export type PanelCookieState = { open: boolean; provider?: string; widthRem?: number };
+const clampWidth = (value: number) => Math.min(PANEL_MAX_WIDTH_REM, Math.max(PANEL_MIN_WIDTH_REM, value));
+
+export function readPanelCookie(cookieHeader: string | null | undefined, providers: readonly string[]): PanelCookieState {
+  const value = cookieHeader
+    ?.split(";")
+    .map((part) => part.trim())
+    .find((part) => part.startsWith(`${PANEL_COOKIE}=`))
+    ?.slice(PANEL_COOKIE.length + 1);
+  if (value === undefined) return { open: false };
+  const parts = value.split(":");
+  const [open, encodedProvider, width] = parts;
+  if (
+    parts.length !== 3 ||
+    (open !== "0" && open !== "1") ||
+    encodedProvider === undefined ||
+    width === undefined ||
+    (width !== "" && !/^\d{1,2}(\.\d{1,2})?$/.test(width))
+  )
+    return { open: false };
+  let provider: string;
+  try {
+    provider = decodeURIComponent(encodedProvider);
+    if (encodeURIComponent(provider) !== encodedProvider) return { open: false };
+  } catch {
+    return { open: false };
+  }
+  if ((provider && !providers.includes(provider)) || (open === "1" && !provider)) return { open: false };
+  return { open: open === "1", ...(provider ? { provider } : {}), ...(width ? { widthRem: clampWidth(Number(width)) } : {}) };
+}
+
+export function serializePanelCookie(state: PanelCookieState, secure: boolean): string {
+  const width = state.widthRem !== undefined && Number.isFinite(state.widthRem) ? Math.round(clampWidth(state.widthRem) * 100) / 100 : "";
+  return `${PANEL_COOKIE}=${state.open && state.provider ? "1" : "0"}:${encodeURIComponent(state.provider ?? "")}:${width}; Path=/; Max-Age=31536000; SameSite=Lax${secure ? "; Secure" : ""}`;
+}

package/src/_internal/registry-validation.ts

@@ -1,37 +1,14 @@
 import { CLOUD_CLI_MODULE_NAME } from "../cli/plugin";
 import { PlatformPermissionSchema } from "../contracts/outgoing-mail";
 import type { AppRegistryEntry } from "../contracts/registry";
+import { isOwnAppPath, SAME_ORIGIN_PATH } from "./app-path";
 
 const isRecord = (value: unknown): value is Record<string, unknown> => typeof value === "object" && value !== null && !Array.isArray(value);
 const isString = (value: unknown): value is string => typeof value === "string";
 const isStringArray = (value: unknown): value is string[] => Array.isArray(value) && value.every(isString);
 const isStringRecord = (value: unknown): value is Record<string, string> => isRecord(value) && Object.values(value).every(isString);
 
-/** An absolute path on the current origin: one leading slash, no backslash or whitespace. */
-const SAME_ORIGIN_PATH = /^\/(?![\/\\])[^\\\s]*$/;
-
-/** A route as the gateway reads it: trimmed and without empty segments, so `//pwa/x/` is `/pwa/x`. */
-export const canonicalRoute = (route: string): string => {
-  const trimmed = route.trim();
-  return trimmed.startsWith("/") ? `/${trimmed.split("/").filter(Boolean).join("/")}` : trimmed;
-};
-
-/**
- * Whether a `nav.badge` path stays below one of the app's own `routes`. It is
- * checked on the path the browser actually requests, after dot segments, and
- * never starts with `//`, which a URL resolver reads as another host.
- */
-export const isOwnNavBadge = (badge: string, routes: readonly string[]): boolean => {
-  if (!SAME_ORIGIN_PATH.test(badge)) return false;
-  const path = new URL(badge, "https://cloud.invalid").pathname;
-  return (
-    !path.startsWith("//") &&
-    routes.some((route) => {
-      const prefix = canonicalRoute(route);
-      return prefix === "/" || path === prefix || path.startsWith(`${prefix}/`);
-    })
-  );
-};
+export { canonicalRoute, isOwnAppPath } from "./app-path";
 
 const invalid = (path: string, expected: string): string => `${path} must be ${expected}`;
 
@@ -69,6 +46,12 @@ export const validateAppRegistryEntry = (value: unknown): string | null => {
       if (!isRecord(translation)) return invalid(`presentation.translations.${locale}`, "an object");
       if (translation.name !== undefined && !isString(translation.name))
         return invalid(`presentation.translations.${locale}.name`, "a string");
+      if (
+        translation.panelLabel !== undefined &&
+        (!isString(translation.panelLabel) || !translation.panelLabel.trim() || value.panel === undefined)
+      ) {
+        return invalid(`presentation.translations.${locale}.panelLabel`, "a non-empty string for a declared panel");
+      }
       if (translation.description !== undefined && !isString(translation.description)) {
         return invalid(`presentation.translations.${locale}.description`, "a string");
       }
@@ -87,10 +70,22 @@ export const validateAppRegistryEntry = (value: unknown): string | null => {
     if (value.nav.requiresRoles !== undefined && !isStringArray(value.nav.requiresRoles)) {
       return invalid("nav.requiresRoles", "an array of strings");
     }
-    if (value.nav.badge !== undefined && (!isString(value.nav.badge) || !isOwnNavBadge(value.nav.badge, value.routes))) {
+    if (value.nav.badge !== undefined && (!isString(value.nav.badge) || !isOwnAppPath(value.nav.badge, value.routes))) {
       return invalid("nav.badge", "a same-origin path below one of the entry's routes");
     }
   }
+  if (value.panel !== undefined) {
+    if (!isRecord(value.panel)) return invalid("panel", "an object");
+    if (!isString(value.panel.href) || !isOwnAppPath(value.panel.href, value.routes)) {
+      return invalid("panel.href", "a same-origin path below one of the entry's routes");
+    }
+    for (const field of ["label", "icon"] as const) {
+      if (!isString(value.panel[field]) || !value.panel[field].trim()) return invalid(`panel.${field}`, "a non-empty string");
+    }
+    if (value.panel.requiresRoles !== undefined && !isStringArray(value.panel.requiresRoles)) {
+      return invalid("panel.requiresRoles", "an array of strings");
+    }
+  }
   if (value.adminNav !== undefined) {
     if (
       !Array.isArray(value.adminNav) ||

package/src/_internal/runtime-context.ts

@@ -58,6 +58,7 @@ export const buildRuntimeFromRegistry = (entries: AppRegistryEntry[], capabiliti
             badge: e.nav.badge,
           }
         : undefined,
+      panel: e.panel ? { ...e.panel, requiresRoles: e.panel.requiresRoles ? [...e.panel.requiresRoles] : undefined } : undefined,
       help: e.help ? { ...e.help } : undefined,
       searchTags,
       searchHelp: searchQueries?.map((query) => query.description).join(" "),

package/src/access/PermissionEditor.browser-harness.tsx

@@ -1,46 +1,65 @@
 import { LocaleProvider } from "@k2b/ui";
+import { createSignal, onCleanup, Show } from "solid-js";
 import { render } from "solid-js/web";
+import type { AccessEntry } from "../contracts/shared";
 import PermissionEditor from "./PermissionEditor";
 
 const host = document.getElementById("root");
 if (!host) throw new Error("Missing harness root");
-render(
-  () => (
+render(() => {
+  let saved: AccessEntry[] = ["Mara Lind", "Lea Sommer", "Jonas Weber"].map((displayName, index) => ({
+    id: `access-${index}`,
+    principal: { type: "user", userId: `user-${index}` },
+    displayName,
+    permission: "read",
+    createdAt: "2026-10-15T07:00:00.000Z",
+  }));
+  const [data, setData] = createSignal(saved);
+  const refetch = () => {
+    // Like a consumer's query: fresh objects contain the saved level and another person's change.
+    saved = saved.map((entry, index) => ({
+      ...entry,
+      principal: { ...entry.principal },
+      ...(index === 2 ? { permission: "write" as const } : {}),
+    }));
+    setData(saved);
+  };
+  document.addEventListener("refetch-access", refetch);
+  onCleanup(() => document.removeEventListener("refetch-access", refetch));
+  return (
     <LocaleProvider locale="en">
-      <PermissionEditor
-        initialEntries={["Mara Lind", "Lea Sommer", "Jonas Weber"].map((displayName, index) => ({
-          id: `access-${index}`,
-          principal: { type: "user", userId: `user-${index}` },
-          displayName,
-          permission: "read",
-          createdAt: "2026-10-15T07:00:00.000Z",
-        }))}
-        // Equal-width labels isolate pending-state layout from a normal change in label width.
-        allowedLevels={[
-          { level: "read", label: "Level 1" },
-          { level: "write", label: "Level 2" },
-        ]}
-        allowAuthenticated={false}
-        grantAccess={async () => {
-          throw new Error("Not used");
-        }}
-        updateAccess={() =>
-          new Promise<void>((resolve) => {
-            // The test waits for this mark, so it does not depend on how the editor shows a pending change.
-            document.documentElement.dataset.saving = "true";
-            document.addEventListener(
-              "settle-access",
-              () => {
-                delete document.documentElement.dataset.saving;
-                resolve();
-              },
-              { once: true },
-            );
-          })
-        }
-        revokeAccess={async () => {}}
-      />
+      <Show when={data()}>
+        {(entries) => (
+          <PermissionEditor
+            initialEntries={entries()}
+            // Equal-width labels isolate pending-state layout from a normal change in label width.
+            allowedLevels={[
+              { level: "read", label: "Level 1" },
+              { level: "write", label: "Level 2" },
+            ]}
+            allowAuthenticated={false}
+            grantAccess={async () => {
+              throw new Error("Not used");
+            }}
+            updateAccess={(id, permission) =>
+              new Promise<void>((resolve) => {
+                // Existing tests use this mark and event to control the save.
+                document.documentElement.dataset.saving = "true";
+                document.addEventListener(
+                  "settle-access",
+                  () => {
+                    saved = saved.map((entry) => (entry.id === id ? { ...entry, permission } : entry));
+                    delete document.documentElement.dataset.saving;
+                    resolve();
+                  },
+                  { once: true },
+                );
+              })
+            }
+            revokeAccess={async () => {}}
+          />
+        )}
+      </Show>
     </LocaleProvider>
-  ),
-  host,
-);
+  );
+}, host);

package/src/access/PermissionEditor.tsx

@@ -1,6 +1,6 @@
 import { mutation } from "@k2b/stdlib/solid";
 import { announce, IconButton, Placeholder, prompts, SelectChip, Tooltip, useLocale } from "@k2b/ui";
-import { createMemo, createSignal, For, onCleanup, Show } from "solid-js";
+import { createEffect, createMemo, createSignal, For, onCleanup, Show } from "solid-js";
 import { createStore, reconcile } from "solid-js/store";
 import { CloudAvatar } from "../account/Avatar";
 import type { AccessEntry, PermissionLevel, Principal, ServiceAccountKind } from "../contracts/shared";
@@ -27,9 +27,9 @@ export type GrantableLevel = Exclude<PermissionLevel, "none">;
 export type AllowedLevel = GrantableLevel | { level: GrantableLevel; scope?: string; label?: string; icon?: string; description?: string };
 
 type PermissionEditorProps = {
-  /** Initial access entries — caller stays the source of truth for
-   *  what's stored on the resource; the editor updates its local copy
-   *  after successful mutations. */
+  /** The editor mounts from this list and merges later lists by entry id once no change is saving.
+   *  Rows the caller changed since its last list win; unchanged rows keep the editor's confirmed result.
+   *  Keep the editor mounted (no keyed Show or unmount during refresh) and pass refetched data. */
   initialEntries: AccessEntry[];
 
   /** Whether the current user can edit permissions. When `false`, the
@@ -179,7 +179,9 @@ export default function PermissionEditor(props: PermissionEditorProps) {
   const t = () => accessMessages.resolve([locale()]).t;
   // A store keeps each row's identity across level changes, so an expanded member list stays open. It holds
   // copies: store writes go into the objects themselves, and the caller's entries are not the editor's to change.
-  const [entries, setEntries] = createStore<AccessEntry[]>(props.initialEntries.map((entry) => ({ ...entry })));
+  const initialEntries = props.initialEntries;
+  let appliedCallerEntries = new Map(initialEntries.map((entry) => [entry.id, JSON.stringify(entry)]));
+  const [entries, setEntries] = createStore<AccessEntry[]>(initialEntries.map((entry) => ({ ...entry })));
   const [pending, setPending] = createSignal<string | null>(null);
   const grantPending = () => pending() !== null;
   let disposed = false;
@@ -281,6 +283,29 @@ export default function PermissionEditor(props: PermissionEditorProps) {
     },
   });
   const busy = () => grantPending() || updateMut.loading() || revokeMut.loading();
+  createEffect(() => {
+    const next = props.initialEntries;
+    const nextCallerEntries = new Map(next.map((entry) => [entry.id, JSON.stringify(entry)]));
+    // Mutation loading clears before onSuccess; wait for its local writes and onFinally too.
+    if (busy() || updating() !== null || revoking() !== null) return;
+    if (
+      nextCallerEntries.size === appliedCallerEntries.size &&
+      next.every((entry) => nextCallerEntries.get(entry.id) === appliedCallerEntries.get(entry.id))
+    )
+      return;
+    // Rows the caller changed since its last list win; unchanged rows keep the editor's confirmed result.
+    const localEntries = new Map(entries.map((entry) => [entry.id, entry]));
+    const merged: AccessEntry[] = [];
+    for (const entry of next) {
+      const row = nextCallerEntries.get(entry.id) !== appliedCallerEntries.get(entry.id) ? entry : localEntries.get(entry.id);
+      if (row) merged.push({ ...row });
+    }
+    for (const entry of entries) {
+      if (!nextCallerEntries.has(entry.id) && !appliedCallerEntries.has(entry.id)) merged.push({ ...entry });
+    }
+    setEntries(reconcile(merged, { key: "id" }));
+    appliedCallerEntries = nextCallerEntries;
+  });
   // The service refuses to remove the last manager; the row says so up front.
   const lastManagerId = createMemo(() => {
     // A grant on part of the resource never manages it.

package/src/access/ResourceApiKeys.tsx

@@ -176,7 +176,11 @@ export default function ResourceApiKeys(props: ResourceApiKeysProps) {
   const createMutation = mutations.create<{ credential: ResourceApiKey; token: string }, CreateResourceApiKeyInput>({
     mutation: props.createKey,
     onSuccess: async (data) => {
-      setKeys([data.credential, ...keys()]);
+      setKeys((current) =>
+        current.some((key) => key.id === data.credential.id)
+          ? current.map((key) => (key.id === data.credential.id ? data.credential : key))
+          : [data.credential, ...current],
+      );
       await prompts.dialog<void>(() => <TokenDialog token={data.token} />, {
         title: t().keyCreated,
         icon: "ti ti-key",

package/src/account/Avatar.tsx

@@ -1,10 +1,14 @@
 import { Avatar, type AvatarProps } from "@k2b/ui";
 import type { JSX } from "solid-js";
 
-export type CloudAvatarProps = Omit<AvatarProps, "name" | "src"> & {
+/** Who an avatar stands for; agents and service accounts are square, people round. */
+export type CloudAvatarKind = "user" | "service_account" | "system";
+
+export type CloudAvatarProps = Omit<AvatarProps, "name" | "src" | "shape" | "icon"> & {
   username: string;
   userId?: string | null;
   avatarHash?: string | null;
+  kind?: CloudAvatarKind;
 };
 
 const avatarSource = (userId?: string | null, avatarHash?: string | null): string | undefined => {
@@ -12,14 +16,28 @@ const avatarSource = (userId?: string | null, avatarHash?: string | null): strin
   return `/api/accounts/users/${encodeURIComponent(userId)}/avatar?rev=${encodeURIComponent(avatarHash)}`;
 };
 
+/** The URL of a person's uploaded picture, or undefined when there is none. */
+export const cloudAvatarSource = avatarSource;
+
+const KIND_ICON: Record<CloudAvatarKind, string | undefined> = {
+  user: undefined,
+  service_account: "ti ti-robot",
+  system: "ti ti-settings-automation",
+};
+
+/** One avatar for every Cloud surface: the uploaded picture when there is one, otherwise initials. */
 export function CloudAvatar(props: CloudAvatarProps): JSX.Element {
+  const kind = () => props.kind ?? "user";
   return (
     <Avatar
       name={props.username}
-      src={avatarSource(props.userId, props.avatarHash)}
+      src={kind() === "user" ? avatarSource(props.userId, props.avatarHash) : undefined}
+      icon={KIND_ICON[kind()]}
+      shape={kind() === "user" ? "circle" : "square"}
       alt={props.alt}
       fallback={props.fallback}
       size={props.size}
+      ring={props.ring}
       loading={props.loading}
       class={props.class}
       style={props.style}

package/src/account/ui.ts

@@ -1,3 +1,3 @@
-export { CloudAvatar, type CloudAvatarProps } from "./Avatar";
+export { CloudAvatar, type CloudAvatarKind, type CloudAvatarProps, cloudAvatarSource } from "./Avatar";
 export { type AvatarUploadDialogOptions, openAvatarUploadDialog } from "./avatar-upload-dialog";
 export { default as EntitySearch, type EntitySearchPrincipal } from "./EntitySearch";

package/src/ai/approval-routes.ts

@@ -56,7 +56,7 @@ type AiApprovalRouteDependencies = {
   limit?: MiddlewareHandler<AuthContext>;
   authenticate?: MiddlewareHandler<AuthContext>;
   listPreferences?: (actorUserId: string, options: { conversationId?: string }) => Promise<AiToolApprovalPreference[]>;
-  revokePreference?: (actorUserId: string, preferenceId: string) => Promise<boolean>;
+  revokePreference?: typeof revokeAiToolApprovalPreference;
   listCapabilities?: () => Promise<CapabilityRegistryEntry[]>;
   /** Resolves a chat the user owns by its ID or short ID. */
   findConversation?: (ownerUserId: string, conversation: string) => Promise<{ id: string } | null>;
@@ -157,7 +157,10 @@ export const createAiApprovalPreferenceRoutes = (dependencies: AiApprovalRouteDe
       v("param", AiApprovalPreferenceParamSchema),
       async (c) => {
         const user = expectUserBackedActor(c);
-        const deleted = await revokePreference(user.id, c.req.valid("param").preferenceId);
+        const deleted = await revokePreference(user.id, c.req.valid("param").preferenceId, {
+          actor: c.get("actor"),
+          requestId: c.req.header("x-request-id") ?? null,
+        });
         return deleted ? c.json({ deleted: true as const }) : c.json({ message: "Approval not found", code: "NOT_FOUND" }, 404);
       },
     );

package/src/ai/approvals.ts

@@ -1,4 +1,8 @@
-import { sql } from "bun";
+import { type SQL, sql } from "bun";
+import type { AccessSubject } from "../contracts/shared";
+import type { RequestActor } from "../server/middleware/auth";
+import { type AuditActor, type AuditRecordParams, audit } from "../services/audit";
+import { toPgTextArray } from "../services/postgres";
 import type { AiToolApprovalPolicy, AiTurnRunConfig } from "./types";
 
 /** Background authority never inherits a user's interactive Always Allow preference. */
@@ -31,6 +35,16 @@ export type AiToolApprovalContext = {
   actorUserId: string;
 };
 
+/**
+ * Request identity for approval changes; never persist this context in a turn run config.
+ * When actor is absent, audit uses { userId: actorUserId } for the approval's owner.
+ * The access subject is derived from actor, or falls back to { type: "user", userId: actorUserId }.
+ */
+export type AiToolApprovalChangeContext = AiToolApprovalContext & {
+  actor?: RequestActor;
+  requestId?: string | null;
+};
+
 /** Where a remembered approval applies: in one chat until it is deleted, or always. */
 export type AiToolApprovalRemember = "chat" | "always";
 
@@ -55,6 +69,59 @@ type AiToolApprovalPreferenceRow = {
   expires_at: Date | string | null;
 };
 
+type ApprovalAuditRow = Pick<AiToolApprovalPreferenceRow, "id" | "tool_name" | "approval_scope" | "conversation_id">;
+type ApprovalAuditIdentity = {
+  actor: AuditActor | null;
+  accessSubject: AccessSubject | null;
+  serviceAccountId?: string;
+  requestId?: string | null;
+  reason?: string;
+};
+
+const approvalAuditIdentity = (context: AiToolApprovalChangeContext): ApprovalAuditIdentity => {
+  const user = context.actor?.kind === "user" ? context.actor.user : context.actor?.delegatedUser;
+  return {
+    actor: context.actor
+      ? user
+        ? { userId: user.id, uid: user.uid, provider: user.provider, roles: user.roles }
+        : null
+      : { userId: context.actorUserId },
+    // Match aiChatAccessSubject locally: importing assistant-models creates a cycle through firecrawl-tools.
+    accessSubject: user
+      ? {
+          type: "user",
+          userId: user.id,
+          ...(context.actor?.kind === "service_account" ? { delegatedByServiceAccountId: context.actor.serviceAccount.id } : {}),
+        }
+      : context.actor?.kind === "service_account"
+        ? { type: "service_account", serviceAccountId: context.actor.serviceAccount.id }
+        : { type: "user", userId: context.actorUserId },
+    ...(context.actor?.kind === "service_account" ? { serviceAccountId: context.actor.serviceAccount.id } : {}),
+    requestId: context.requestId,
+  };
+};
+
+const approvalAuditEvent = (
+  action: "ai.approval.remember" | "ai.approval.revoke",
+  row: ApprovalAuditRow,
+  identity: ApprovalAuditIdentity,
+): AuditRecordParams => ({
+  action,
+  outcome: "allowed",
+  actor: identity.actor,
+  target: { type: "ai_approval", id: row.id, label: row.tool_name },
+  requestId: identity.requestId,
+  reason: identity.reason,
+  metadata: {
+    toolName: row.tool_name,
+    approvalScope: row.approval_scope,
+    remember: row.conversation_id !== null ? "chat" : "always",
+    ...(row.conversation_id !== null ? { conversationId: row.conversation_id } : {}),
+    accessSubject: identity.accessSubject,
+    ...(identity.serviceAccountId ? { serviceAccountId: identity.serviceAccountId } : {}),
+  },
+});
+
 export const aiToolApprovalScope = (toolName: string, policy: AiToolApprovalPolicy | undefined): string => {
   if (policy && typeof policy === "object") return policy.scope ?? toolName;
   return toolName;
@@ -100,20 +167,12 @@ export const hasRememberedAiToolApproval = async (
 
 /** Remembers an approval everywhere, or in one chat when `conversationId` is set; a chat approval ends with its chat. */
 export const rememberAiToolApproval = async (
-  context: AiToolApprovalContext,
+  context: AiToolApprovalChangeContext,
   input: { toolName: string; approvalScope: string; conversationId?: string | null; expiresAt?: Date | null },
 ): Promise<void> => {
   const conversationId = input.conversationId ?? null;
-  await sql.begin(async () => {
-    await sql`
-      DELETE FROM ai.tool_approval_preferences
-      WHERE actor_user_id = ${context.actorUserId}
-        AND tool_name = ${input.toolName}
-        AND approval_scope = ${input.approvalScope}
-        AND conversation_id IS NOT DISTINCT FROM ${conversationId}::uuid
-    `;
-
-    await sql`
+  await sql.begin(async (tx) => {
+    const [row] = await tx<{ id: string }[]>`
       INSERT INTO ai.tool_approval_preferences (
         actor_user_id,
         tool_name,
@@ -130,24 +189,46 @@ export const rememberAiToolApproval = async (
         now(),
         ${input.expiresAt ?? null}
       )
+      ON CONFLICT (actor_user_id, tool_name, approval_scope, conversation_id)
+      DO UPDATE SET
+        created_at = EXCLUDED.created_at,
+        last_used_at = EXCLUDED.last_used_at,
+        expires_at = EXCLUDED.expires_at
+      RETURNING id
     `;
+    await audit.record(
+      approvalAuditEvent(
+        "ai.approval.remember",
+        {
+          id: row!.id,
+          tool_name: input.toolName,
+          approval_scope: input.approvalScope,
+          conversation_id: conversationId,
+        },
+        approvalAuditIdentity(context),
+      ),
+      tx,
+    );
   });
 };
 
 /** Forgets the approval with exactly this reach: everywhere, or in the one chat `conversationId` names. */
 export const forgetAiToolApproval = async (
-  context: AiToolApprovalContext,
+  context: AiToolApprovalChangeContext,
   input: { toolName: string; approvalScope: string; conversationId?: string | null },
 ): Promise<boolean> => {
-  const rows = await sql<{ id: string }[]>`
-    DELETE FROM ai.tool_approval_preferences
-    WHERE actor_user_id = ${context.actorUserId}
-      AND tool_name = ${input.toolName}
-      AND approval_scope = ${input.approvalScope}
-      AND conversation_id IS NOT DISTINCT FROM ${input.conversationId ?? null}::uuid
-    RETURNING id
-  `;
-  return rows.length > 0;
+  return sql.begin(async (tx) => {
+    const rows = await tx<ApprovalAuditRow[]>`
+      DELETE FROM ai.tool_approval_preferences
+      WHERE actor_user_id = ${context.actorUserId}
+        AND tool_name = ${input.toolName}
+        AND approval_scope = ${input.approvalScope}
+        AND conversation_id IS NOT DISTINCT FROM ${input.conversationId ?? null}::uuid
+      RETURNING id, tool_name, approval_scope, conversation_id
+    `;
+    for (const row of rows) await audit.record(approvalAuditEvent("ai.approval.revoke", row, approvalAuditIdentity(context)), tx);
+    return rows.length > 0;
+  });
 };
 
 const toIsoString = (value: Date | string): string => (value instanceof Date ? value : new Date(value)).toISOString();
@@ -186,12 +267,42 @@ export const listAiToolApprovalPreferences = async (
   return rows.map(approvalPreferenceFromRow);
 };
 
-export const revokeAiToolApprovalPreference = async (actorUserId: string, preferenceId: string): Promise<boolean> => {
-  const rows = await sql<{ id: string }[]>`
+export const revokeAiToolApprovalPreference = async (
+  actorUserId: string,
+  preferenceId: string,
+  change?: { actor?: RequestActor; requestId?: string | null },
+): Promise<boolean> =>
+  sql.begin(async (tx) => {
+    const rows = await tx<ApprovalAuditRow[]>`
+      DELETE FROM ai.tool_approval_preferences
+      WHERE id = ${preferenceId}
+        AND actor_user_id = ${actorUserId}
+      RETURNING id, tool_name, approval_scope, conversation_id
+    `;
+    for (const row of rows)
+      await audit.record(approvalAuditEvent("ai.approval.revoke", row, approvalAuditIdentity({ ...change, actorUserId })), tx);
+    return rows.length > 0;
+  });
+
+/** Core migrations supply their transaction so deletion and system audit events commit together. */
+export const revokeAiToolApprovalPreferencesAsSystem = async (
+  db: SQL,
+  input: { ids: readonly string[]; reason: string },
+): Promise<number> => {
+  if (input.ids.length === 0) return 0;
+  const rows = await db<(ApprovalAuditRow & { actor_user_id: string | null })[]>`
     DELETE FROM ai.tool_approval_preferences
-    WHERE id = ${preferenceId}
-      AND actor_user_id = ${actorUserId}
-    RETURNING id
+    WHERE id = ANY(${toPgTextArray([...input.ids])}::uuid[])
+    RETURNING id, tool_name, approval_scope, conversation_id, actor_user_id
   `;
-  return rows.length > 0;
+  for (const row of rows)
+    await audit.record(
+      approvalAuditEvent("ai.approval.revoke", row, {
+        actor: null,
+        accessSubject: row.actor_user_id === null ? null : { type: "user", userId: row.actor_user_id },
+        reason: input.reason,
+      }),
+      db,
+    );
+  return rows.length;
 };

package/src/ai/browser.ts

@@ -25,6 +25,7 @@ export {
   cloudAiChartRenderOptions,
   cloudAiChartRows,
   cloudAiChartTable,
+  cloudAiChartTooltip,
   cloudAiChartXValueFormat,
   cloudAiNumberFormatters,
 } from "./chart-block";
@@ -188,6 +189,16 @@ export const launchAssistant = async (input: LaunchAssistantInput): Promise<Assi
   };
 };
 
+export {
+  CHAT_TASK_REASON_CODES,
+  type ChatTaskReason,
+  type ChatTaskReasonCode,
+  chatTaskLocale,
+  chatTaskNeedsNewTime,
+  chatTaskReasonSentence,
+  chatTaskReasonState,
+  chatTaskStopSentence,
+} from "./chat-task-reasons";
 export {
   CLOUD_AI_STATS_MAX_ITEMS,
   CLOUD_AI_TABLE_MAX_COLUMNS,