@k2b/cloud 0.39.0 → 0.41.0

package/src/ai/tool-wording.ts

@@ -2,17 +2,24 @@ import {
   type CapabilityActionWording,
   capabilityActionOutcome,
   capabilityActionSubject,
-  resolveCapabilityActionSentences,
+  capabilityReviewSentence,
+  capabilitySentenceText,
 } from "../_internal/capability-sentences";
-import { displayToolName, isRecord } from "./chat/message-utils";
+import { CapabilityActionReceiptSchema } from "../contracts/capabilities";
+import { type AiStoredActionReview, isLegacyActionReview, storedActionReview } from "./action-review";
+import { isRecord } from "./chat/message-utils";
 import type { AiTurnBlock } from "./protocol";
-import { CLOUD_AI_TOOL_PRESENTATION } from "./tool-sentences";
+import { cloudToolReview } from "./tool-sentences";
 
 type ToolBlock = Extract<AiTurnBlock, { kind: "tool" }>;
 
+/** The review Cloud stored for the call, else the one its open approval carries. */
+const reviewOf = (block: ToolBlock): AiStoredActionReview | null =>
+  block.review ?? (block.approval?.review ? storedActionReview(block.approval.review) : null);
+
 /**
  * How the chat words one call that acts on something: an app Action through its saved presentation, a
- * Cloud tool through Cloud's own catalog of the same shape. `null` for calls that only read.
+ * Cloud tool through its per-call review. `null` for calls that only read.
  */
 export const toolWording = (block: ToolBlock, locale: string): CapabilityActionWording | null => {
   const presentation = block.presentation;
@@ -24,21 +31,42 @@ export const toolWording = (block: ToolBlock, locale: string): CapabilityActionW
       ...(presentation.fields ? { fields: presentation.fields } : {}),
     };
   }
-  const sentences = resolveCapabilityActionSentences(block.name, CLOUD_AI_TOOL_PRESENTATION, locale);
-  return sentences ? { title: displayToolName(block.name, locale), sentences } : null;
+  const review = cloudToolReview(block.name, block.args, locale);
+  return review
+    ? { title: capabilitySentenceText(review.sentence.action, review.slots, { locale: review.locale, timeZone: "UTC" }) }
+    : null;
 };
 
-/** What the call does or would do, as one sentence; `null` for calls that only read. */
+/**
+ * What the call does or would do, as one sentence; `null` for calls that only read. A stored review's action sentence
+ * wins, so it reads the same after a reload and after the app changed. An old review's message is the question of the
+ * card, not the call's short subject: steps and receipts keep the app's catalog sentence.
+ */
 export const toolSubject = (block: ToolBlock, locale: string, timeZone: string): string | null => {
+  const review = reviewOf(block);
+  if (review && !isLegacyActionReview(review))
+    return capabilitySentenceText(review.sentence.action, review.slots, { locale: review.locale, timeZone });
+  const cloudReview = cloudToolReview(block.name, block.args, locale);
+  if (cloudReview) return capabilitySentenceText(cloudReview.sentence.action, cloudReview.slots, { locale: cloudReview.locale, timeZone });
   const wording = toolWording(block, locale);
   return wording ? capabilityActionSubject(wording, block.args, { locale, timeZone }) : null;
 };
 
 /** The sentence for one outcome, or `null` when the tool has none that renders for this call. */
 export const toolOutcome = (block: ToolBlock, key: "done" | "rejected" | "notRun", locale: string, timeZone: string): string | null => {
+  const result = isRecord(block.result) ? block.result : undefined;
+  const review = reviewOf(block);
+  if (review && !isLegacyActionReview(review)) {
+    const receipt = key === "done" ? CapabilityActionReceiptSchema.safeParse(result?.receipt) : null;
+    if (receipt?.success) return capabilitySentenceText(receipt.data.text, receipt.data.slots ?? {}, { locale: review.locale, timeZone });
+    return capabilityReviewSentence(review, key, { timeZone });
+  }
+  if (review && key === "done" && review.legacy.summary) return review.legacy.summary;
+  const cloudReview = cloudToolReview(block.name, block.args, locale);
+  // Only a form the tool names; otherwise the card keeps Cloud's own outcome words for the call.
+  if (cloudReview) return key === "done" || cloudReview.sentence[key] ? capabilityReviewSentence(cloudReview, key, { timeZone }) : null;
   const wording = toolWording(block, locale);
   if (!wording) return null;
-  const result = isRecord(block.result) ? block.result : undefined;
   // App Actions return their data inside the result envelope; Cloud tools return the data itself.
   const data = block.presentation?.kind === "capability" ? result?.data : block.result;
   return capabilityActionOutcome(wording, key, { input: block.args, data }, { locale, timeZone });

package/src/ai/tools.ts

@@ -1,6 +1,7 @@
 import type { Tool, ToolContext } from "@k2b/nessi";
 import { defineTool as defineNessiTool } from "@k2b/nessi";
 import type { z } from "zod";
+import type { CapabilityActionCallReview } from "../contracts/capabilities";
 import type { RequestActor } from "../server";
 import { aiToolNeedsApproval } from "./approvals";
 import type {
@@ -64,7 +65,7 @@ export const defineAiTool = <TInput extends z.ZodType, TOutput extends z.ZodType
           /** Localized short status; never include payloads or secrets. */
           reportProgress?: (message: string) => Promise<void>;
           /** Asks like `requestApproval`, and lets the person remember the approval of `target`. */
-          requestApprovalFor?: (message: string, target: AiApprovalTarget) => Promise<boolean>;
+          requestApprovalFor?: (message: string, target: AiApprovalTarget, review?: CapabilityActionCallReview) => Promise<boolean>;
           /** Relays a decision for an effect another platform component consumes and executes. */
           requestRelayedApproval?: (message: string, options: { approvalId?: string; target?: AiApprovalTarget }) => Promise<boolean>;
           /** Shows requests a website approval let through as they go out, so the chat keeps them whatever the outcome. */
@@ -122,6 +123,8 @@ export type AiToolPreparationContext = {
   linkApproval?: (approvalCallId: string, approvalId: string) => void;
   /** Hears what a nested approval asks for before the approval is requested. */
   describeApproval?: (approvalCallId: string, target: AiApprovalTarget) => void;
+  /** Registers the deterministic review before requesting or consuming a nested approval. */
+  describeReview?: (approvalCallId: string, review: CapabilityActionCallReview) => void | Promise<void>;
   reportWebsiteReceipts?: (callId: string, receipts: AiWebsiteReceipt[]) => Promise<void>;
 };
 
@@ -168,10 +171,11 @@ export const prepareAiTools = (input: AiToolPreparationContext & { tools?: AiRun
     }
     // Nessi numbers the approvals of one execution in request order; count them to name each one's call ID.
     let approvals = 0;
-    const requestApproval = async (message: string, target?: AiApprovalTarget): Promise<boolean> => {
+    const requestApproval = async (message: string, target?: AiApprovalTarget, review?: CapabilityActionCallReview): Promise<boolean> => {
       while (true) {
         const approvalCallId = `${callId}-approval-${approvals++}`;
         if (target) input.describeApproval?.(approvalCallId, target);
+        if (review) await input.describeReview?.(approvalCallId, review);
         if (!(await ctx.requestApproval(message))) return false;
         const used = await use(approvalCallId);
         if (used === "approved") return true;
@@ -182,7 +186,8 @@ export const prepareAiTools = (input: AiToolPreparationContext & { tools?: AiRun
     return {
       ...ctx,
       requestApproval,
-      requestApprovalFor: (message: string, target: AiApprovalTarget) => requestApproval(message, target),
+      requestApprovalFor: (message: string, target: AiApprovalTarget, review?: CapabilityActionCallReview) =>
+        requestApproval(message, target, review),
       requestRelayedApproval: async (message: string, options: { approvalId?: string; target?: AiApprovalTarget }) => {
         const approvalCallId = `${callId}-approval-${approvals++}`;
         if (options.approvalId) input.linkApproval?.(approvalCallId, options.approvalId);

package/src/ai/types.ts

@@ -13,11 +13,37 @@ import type {
 import type { Usage } from "@k2b/nessi/ai";
 import type { z } from "zod";
 import type { CapabilitySentenceField } from "../_internal/capability-sentences";
-import type { CapabilityActionReview, CapabilityActionSentences, CloudResourceRef } from "../contracts/capabilities";
+import type {
+  CapabilityActionCallReview,
+  CapabilityActionReviewData,
+  CapabilityActionSentences,
+  CloudResourceRef,
+} from "../contracts/capabilities";
 import type { RequestActor } from "../server";
+import type { AiActionCheck, AiStoredActionReview } from "./action-review";
 import type { AiLocalClient, AiLocalContext, AiLocalToolName } from "./local-tool-contracts";
 import type { AiTurnBlock } from "./protocol";
 
+/** Current reader-confirmed metadata for a recently sent resource. */
+export type AiRecentResource = {
+  ref: CloudResourceRef;
+  title: string;
+  icon?: string;
+  href?: string;
+  kind: string;
+  preview?: string;
+  appName: string;
+  count: number;
+};
+
+export type AiRecentSentResourceRef = {
+  ref: CloudResourceRef;
+  count: number;
+  lastSentAt: string;
+  /** Internal conversation UUID, only for authorized Studio reads. */
+  conversationId: string;
+};
+
 export const AI_MODEL_CAPABILITIES = ["streaming", "tools", "vision", "transcription"] as const;
 export type AiModelCapability = (typeof AI_MODEL_CAPABILITIES)[number];
 
@@ -308,6 +334,8 @@ export type AiStoredMessage = {
       trigger: "scheduled" | "manual";
     };
     toolPresentations?: Record<string, AiToolPresentation>;
+    toolReviews?: Record<string, AiStoredActionReview>;
+    toolChecks?: Record<string, AiActionCheck>;
     /** How the person decided an approval; `expired` when the turn ended while it still waited. */
     toolOutcomes?: Record<string, "rejected" | "approved" | "expired">;
     /** Requests a website approval let through, by tool call and then by `AiWebsiteReceipt.index`. */
@@ -428,7 +456,14 @@ export type AiPendingTurnAction =
       name: string;
       args: unknown;
       message?: string;
-      review?: CapabilityActionReview;
+      /** Stored review, including the declared ask reason for new-shape reviews. */
+      review?: CapabilityActionReviewData;
+      /** Owning application, with its registry name in the turn's request locale. */
+      app?: { id: string; name: string };
+      /** The chat's current title, when known. */
+      chatTitle?: string | null;
+      /** Expiry of the platform approval request, as an ISO timestamp. */
+      expiresAt?: string;
       allowAlways: boolean;
       /** Whether the approval can be remembered for this chat. */
       allowChat: boolean;
@@ -464,7 +499,7 @@ export type AiPendingTurnActionRecord = {
   name: string;
   args: unknown;
   message?: string;
-  review?: CapabilityActionReview;
+  review?: CapabilityActionReviewData;
   approvalScope: string;
   allowAlways: boolean;
   /** Whether the approval can be remembered for this chat; defaults to `allowAlways`. */
@@ -621,6 +656,7 @@ export type AiBackgroundRunContext = {
   trigger?: "scheduled" | "manual";
   timezone?: string;
   stopDeliveredAt?: string;
+  needsApproval?: { action: string };
   taskId: string;
   occurrenceId: string;
   context: Array<{ seq: number; kind: "message" | "summary"; message: Message }>;
@@ -765,6 +801,7 @@ export type AiConversationService = {
     before?: string;
     limit?: number;
   }): Promise<{ resources: AiConversationResourceRef[]; nextCursor?: string }>;
+  listRecentSentResourceRefs(input: { ownerUserId: string }): Promise<AiRecentSentResourceRef[]>;
   listUserConversationResources(input: {
     ownerUserId: string;
     search?: string;
@@ -1007,6 +1044,8 @@ export type AiConversationService = {
   getPendingTurnAction(input: { conversationId: string; turnId: string; callId: string }): Promise<AiPendingTurnActionRecord | null>;
   findPendingTurnActionByApproval(input: { approvalId: string; ownerUserId: string }): Promise<AiPendingTurnActionRecord | null>;
   listPendingActionRecords(input: { conversationId: string; turnId: string }): Promise<AiPendingTurnActionRecord[]>;
+  /** The reviews Cloud stored with a turn's tool calls, keyed by call ID; the newest message wins. */
+  listTurnToolReviews(input: { conversationId: string; turnId: string }): Promise<Map<string, AiStoredActionReview>>;
   listResolvedPendingActions(input: { conversationId: string; turnId: string }): Promise<AiPendingTurnActionRecord[]>;
   resolvePendingTurnAction(input: {
     conversationId: string;
@@ -1126,7 +1165,7 @@ export type AiToolRuntime<TInput extends z.ZodType = z.ZodType, TOutput extends
           /** Localized short status; never include payloads or secrets. */
           reportProgress?: (message: string) => Promise<void>;
           /** Asks like `requestApproval`, and lets the person remember the approval of `target`. */
-          requestApprovalFor?: (message: string, target: AiApprovalTarget) => Promise<boolean>;
+          requestApprovalFor?: (message: string, target: AiApprovalTarget, review?: CapabilityActionCallReview) => Promise<boolean>;
           /** Relays a decision for an effect another platform component consumes and executes. */
           requestRelayedApproval?: (message: string, options: { approvalId?: string; target?: AiApprovalTarget }) => Promise<boolean>;
           /** Shows requests a website approval let through as they go out, so the chat keeps them whatever the outcome. */

package/src/api/accounts-entities.ts

@@ -14,6 +14,7 @@ import {
   UserProviderSchema,
 } from "../contracts";
 import { type AuthContext, auth, expectUserBackedActor, jsonResponse, requiresAuth, respond, v } from "../server";
+import { noTransform } from "../server/middleware/no-transform";
 import { accountsAppService as accountsService } from "../services";
 
 const EntitiesListResponseSchema = z.object({
@@ -91,7 +92,7 @@ type AccountsEntitiesRouteDependencies = {
 };
 
 export const createAccountsEntitiesRoutes = (dependencies: AccountsEntitiesRouteDependencies = {}) =>
-  new Hono<AuthContext>().get(
+  new Hono<AuthContext>().use("/entities/*", noTransform()).get(
     "/entities",
     dependencies.authenticate ?? auth.requireRole("authenticated"),
     dependencies.requireUser ?? auth.requireUser(),

package/src/api/admin-ai-projects.ts

@@ -3,6 +3,7 @@ import { z } from "zod";
 import { AiProjectLastAdminError, aiProjects } from "../ai/projects";
 import { AuthenticatedPrincipalSchema } from "../contracts/shared";
 import { type AuthContext, auth, err, fail, ok, respond, v } from "../server";
+import { noTransform } from "../server/middleware/no-transform";
 
 const ListProjectsSchema = z
   .object({
@@ -20,6 +21,7 @@ const lastAdminConflict = (c: Parameters<typeof respond>[0], error: AiProjectLas
 
 export const createAdminAiProjectsRoutes = (authenticate: MiddlewareHandler<AuthContext> = auth.requireRole("admin")) =>
   new Hono<AuthContext>()
+    .use("*", noTransform())
     .use("*", authenticate)
     .get("/", v("query", ListProjectsSchema), async (c) => {
       const query = c.req.valid("query");

package/src/api/admin-ai-skills.ts

@@ -4,6 +4,7 @@ import { aiAppSkills } from "../ai/app-skill-store";
 import { AiSkillInputError, AiSkillLastAdminError, AiSkillRevisionConflictError, aiSkills } from "../ai/skills";
 import { AuthenticatedPrincipalSchema } from "../contracts/shared";
 import { type AuthContext, auth, err, fail, ok, respond, v } from "../server";
+import { noTransform } from "../server/middleware/no-transform";
 
 const ListSkillsSchema = z
   .object({
@@ -32,6 +33,7 @@ const installAppSkill = async (c: Parameters<typeof respond>[0], install: () =>
 
 export const createAdminAiSkillsRoutes = (authenticate: MiddlewareHandler<AuthContext> = auth.requireRole("admin")) =>
   new Hono<AuthContext>()
+    .use("*", noTransform())
     .use("*", authenticate)
     .get("/", v("query", ListSkillsSchema), async (c) => {
       const query = c.req.valid("query");

package/src/api/admin-ai-usage.ts

@@ -3,6 +3,7 @@ import { describeRoute } from "hono-openapi";
 import { z } from "zod";
 import { aiUsage } from "../ai/usage";
 import { type AuthContext, auth, err, fail, ok, respond, v } from "../server";
+import { noTransform } from "../server/middleware/no-transform";
 import { AiUsageQuerySchema } from "../shared/ai-usage";
 
 export const createAdminAiUsageRoutes = (
@@ -10,6 +11,7 @@ export const createAdminAiUsageRoutes = (
   service: typeof aiUsage = aiUsage,
 ) =>
   new Hono<AuthContext>()
+    .use("*", noTransform())
     .use("*", authenticate)
     .get(
       "/report",

package/src/api/admin-geoip.ts

@@ -0,0 +1,80 @@
+import { Hono, type MiddlewareHandler } from "hono";
+import { describeRoute } from "hono-openapi";
+import { z } from "zod";
+import { GEOIP_MAX_DATABASE_BYTES, GEOIP_MAX_REQUEST_BYTES } from "../contracts/geoip";
+import { type AuthContext, auth, v } from "../server";
+import { REQUEST_IDLE_TIMEOUT_MAX_SECONDS, REQUEST_IDLE_TIMEOUT_SECONDS, setRequestTimeout } from "../server/request-timeout";
+import { GeoIpError, geoip } from "../services/geoip";
+
+export const createAdminGeoIpRoutes = (
+  authenticate: MiddlewareHandler<AuthContext> = auth.requireRole("admin"),
+  service: typeof geoip = geoip,
+) =>
+  new Hono<AuthContext>()
+    .use(authenticate)
+    .onError((error, c) => {
+      if (error instanceof GeoIpError)
+        return c.json(
+          {
+            code: error.code,
+            ...(error.code === "geoip_too_large" ? { maxDatabaseBytes: GEOIP_MAX_DATABASE_BYTES } : {}),
+            ...(error.code === "geoip_request_too_large" ? { maxRequestBytes: GEOIP_MAX_REQUEST_BYTES } : {}),
+          },
+          error.status,
+        );
+      if (c.req.raw.signal.aborted) return new Response(null, { status: 499 });
+      throw error;
+    })
+    .get(
+      "/",
+      describeRoute({ tags: ["Sign-in locations"], summary: "Show active sign-in location databases and upload limits" }),
+      auth.requireOAuthScope("read", "admin"),
+      async (c) => c.json(await service.status(c.get("user"))),
+    )
+    .put(
+      "/",
+      describeRoute({
+        tags: ["Sign-in locations"],
+        summary: "Replace a City or ASN database with a raw or gzip MMDB upload",
+        requestBody: {
+          required: true,
+          content: {
+            "application/octet-stream": { schema: { type: "string", format: "binary" } },
+            "application/gzip": { schema: { type: "string", format: "binary" } },
+          },
+        },
+      }),
+      auth.requireOAuthScope("write", "admin"),
+      async (c) => {
+        setRequestTimeout(c, REQUEST_IDLE_TIMEOUT_MAX_SECONDS);
+        try {
+          const length = c.req.header("Content-Length");
+          return c.json(
+            await service.upload(
+              c.get("user"),
+              c.req.raw.body ??
+                new ReadableStream({
+                  start(controller) {
+                    controller.close();
+                  },
+                }),
+              {
+                contentLength: length === undefined ? undefined : Number(length),
+                signal: c.req.raw.signal,
+              },
+            ),
+          );
+        } finally {
+          setRequestTimeout(c, REQUEST_IDLE_TIMEOUT_SECONDS);
+        }
+      },
+    )
+    .delete(
+      "/:kind",
+      describeRoute({ tags: ["Sign-in locations"], summary: "Reset one sign-in database to the bundled snapshot" }),
+      auth.requireOAuthScope("write", "admin"),
+      v("param", z.object({ kind: z.enum(["city", "asn"]) })),
+      async (c) => c.json(await service.reset(c.get("user"), c.req.valid("param").kind)),
+    );
+
+export default createAdminGeoIpRoutes();

package/src/api/admin-identity.ts

@@ -7,6 +7,7 @@ import { listApps } from "../_internal/registry";
 import { CapabilityAppIdSchema } from "../contracts/capabilities";
 import { AI_INFERENCE_SCOPE } from "../contracts/shared";
 import { type AuthContext, auth, err, respond, v } from "../server";
+import { noTransform } from "../server/middleware/no-transform";
 import { audit } from "../services/audit";
 import { getIdentitySigningKeyStatus, identityMetrics, revokeIdentitySigningKey, rewrapIdentitySigningKeys } from "../services/identity";
 import { WORKLOAD_SCOPES } from "../services/identity/workload-auth";
@@ -110,6 +111,8 @@ export const createAdminIdentityRoutes = (
   service: IdentityAdminDependencies = dependencies,
 ) =>
   new Hono<AuthContext>()
+    // Mandate lists hold every user's grant inputs, which users write at will and which can carry private text.
+    .use("*", noTransform())
     .use(authenticate)
     .use("*", async (c, next) => {
       c.header("Cache-Control", "no-store");

package/src/api/admin-lifecycle.ts

@@ -4,6 +4,7 @@ import { describeRoute } from "hono-openapi";
 import { z } from "zod";
 import { createPagination, ErrorResponseSchema, MessageResponseSchema, PaginationQuerySchema, parsePagination } from "../contracts";
 import { type AuthContext, auth, jsonResponse, requiresAdmin, respond, v } from "../server";
+import { noTransform } from "../server/middleware/no-transform";
 import { accountLifecycle, lifecycleJobs } from "../services";
 
 const DeletedAccountSchema = z.object({
@@ -63,7 +64,9 @@ const TriggerJobResponseSchema = z.object({
   jobId: z.string(),
 });
 
+// Deleted-account and reminder reports list other accounts' personal data next to requester-controlled identity text.
 const app = new Hono<AuthContext>()
+  .use("*", noTransform())
   .use(auth.requireRole("admin"))
   .get(
     "/deleted-accounts",

package/src/api/admin-outgoing-mail.ts

@@ -14,6 +14,7 @@ import {
   MailStatusSchema,
 } from "../contracts/outgoing-mail";
 import { type AuthContext, auth, jsonResponse, requiresAdmin } from "../server";
+import { noTransform } from "../server/middleware/no-transform";
 import { audit } from "../services/audit";
 import { outgoingMailLog } from "../services/outgoing-mail/admin";
 import { MAIL_RETENTION_KEYS, readMailRetention } from "../services/outgoing-mail/retention";
@@ -96,6 +97,7 @@ const contentResponse = z.union([
 ]);
 export const createAdminOutgoingMailRoutes = (authenticate: MiddlewareHandler<AuthContext> = auth.requireRole("admin")) =>
   new Hono<AuthContext>()
+    .use("*", noTransform())
     .use("*", authenticate)
     .use("*", async (c, next) => {
       c.header("Cache-Control", "no-store");

package/src/api/app-approval-actions.ts

@@ -1,20 +1,44 @@
 import { submitAiTurnAction } from "../ai/runtime";
 import { aiConversations } from "../ai/store";
-import { APP_ACTION_LIMITS } from "../contracts/app-approval";
+import { APP_ACTION_LIMITS, type AppActionSummary } from "../contracts/app-approval";
+import { APPROVALS_PAGE_SIZE } from "../contracts/approvals";
 import type { AppDeviceActions } from "../services/app-approval";
-import { listPending } from "../services/approvals";
-import { appActionSummary, appActionView } from "../services/approvals/device";
+import { listPending, loadApprovalActionPolicies, pendingApprovalCard } from "../services/approvals";
+import { appActionOffered, appActionSummary, appActionView } from "../services/approvals/device";
+
+/** Pages of open requests one inbox poll reads at most while it skips browser-only questions. */
+const INBOX_PAGES = 5;
 
 export const createDeviceActions = (appName: (appId: string, locale: string) => string): AppDeviceActions => {
   const view: AppDeviceActions["view"] = async ({ userId, issuer, actionId }) => {
     const { items } = await listPending({ approverUserId: userId, id: actionId, limit: 1 });
-    return items[0] ? appActionView(items[0], { issuer, appName }) : null;
+    const row = items[0];
+    if (!row) return null;
+    const policy = (await loadApprovalActionPolicies([row]))(row);
+    const mapped = await appActionView(row, { issuer, appName, policy });
+    return appActionOffered(mapped, pendingApprovalCard(row, appName, policy), policy) ? mapped : null;
   };
   return {
     inbox: async ({ userId, issuer }) => {
-      const { items, count } = await listPending({ approverUserId: userId, limit: APP_ACTION_LIMITS.inboxActions });
-      const views = await Promise.all(items.map((row) => appActionView(row, { issuer, appName })));
-      return { actions: views.map(appActionSummary), moreActions: Math.max(0, count - items.length) };
+      // Browser-only questions are skipped, so read on past them. One poll reads at most this many pages of open
+      // requests, newest first, which keeps each 5-second poll bounded.
+      const actions: AppActionSummary[] = [];
+      let count = 0;
+      let cursor: string | undefined;
+      for (let page = 0; page < INBOX_PAGES && actions.length < APP_ACTION_LIMITS.inboxActions; page += 1) {
+        const result = await listPending({ approverUserId: userId, limit: APPROVALS_PAGE_SIZE, ...(cursor ? { cursor } : {}) });
+        count = result.count;
+        const policyOf = await loadApprovalActionPolicies(result.items);
+        for (const row of result.items) {
+          const policy = policyOf(row);
+          const mapped = await appActionView(row, { issuer, appName, policy });
+          if (appActionOffered(mapped, pendingApprovalCard(row, appName, policy), policy)) actions.push(appActionSummary(mapped));
+          if (actions.length === APP_ACTION_LIMITS.inboxActions) break;
+        }
+        if (!result.nextCursor) break;
+        cursor = result.nextCursor;
+      }
+      return { actions, moreActions: Math.max(0, count - actions.length) };
     },
     view,
     decide: async ({ userId, deviceId, issuer, actionId, digest, approved }) => {

package/src/api/app-approval.ts

@@ -5,6 +5,8 @@ import { describeRoute } from "hono-openapi";
 import { z } from "zod";
 import {
   APP_APPROVAL_LIMITS,
+  AppDeviceChangeLookupSchema,
+  AppDeviceChangeReferenceSchema,
   AppDeviceMutationSchema,
   AppDeviceRequestSchema,
   AppLoginReferenceSchema,
@@ -15,6 +17,8 @@ import {
   AppPairingStartSchema,
 } from "../contracts/app-approval";
 import { type AuthContext, auth, rateLimit, v } from "../server";
+import { noTransform } from "../server/middleware/no-transform";
+import { addressPrefix, clientIp, describeRequest } from "../server/request-context";
 import {
   type AppApprovalActor,
   AppApprovalError,
@@ -22,6 +26,8 @@ import {
   appApproval,
   type createAppApprovalService,
 } from "../services/app-approval";
+import { type NewBrowserSignInNotifier, readBrowserCookie } from "../services/known-browsers";
+import { SessionAppDeviceInactiveError, SessionEpochChangedError } from "../services/session";
 import { appNameIn } from "../ssr/runtime";
 import { createDeviceActions } from "./app-approval-actions";
 
@@ -30,7 +36,12 @@ const DevicePageSchema = z.object({ after: z.string().uuid().optional() }).stric
 type Service = ReturnType<typeof createAppApprovalService>;
 
 /** This is a separate credential surface, never a user API-key or OAuth scope. */
-export const createAppApprovalRoutes = (service: Service = appApproval, actions = createDeviceActions, terminal?: AppTerminalLogins) => {
+export const createAppApprovalRoutes = (
+  options: { notify: NewBrowserSignInNotifier },
+  service: Service = appApproval,
+  actions = createDeviceActions,
+  terminal?: AppTerminalLogins,
+) => {
   const actor = async (c: Parameters<typeof auth.session.getToken>[0]): Promise<AppApprovalActor> => {
     // The web session (or an explicit bearer session), never the mobile app's session: a phone
     // that pairs sign-in devices would hand out authority that outlives its removal.
@@ -42,6 +53,8 @@ export const createAppApprovalRoutes = (service: Service = appApproval, actions
     return { userId: session.user.id, sid: session.data.sid, admin: session.user.roles.includes("admin") };
   };
   return new Hono<AuthContext>()
+    .use("/device", noTransform())
+    .use("/device/*", noTransform())
     .onError((error, c) => {
       if (error instanceof AppApprovalError) return c.json({ code: error.code, message: error.code }, error.status);
       if (error instanceof HTTPException && error.status < 500) return c.json({ code: "INVALID_REQUEST" }, error.status);
@@ -95,7 +108,19 @@ export const createAppApprovalRoutes = (service: Service = appApproval, actions
     )
     .post("/manage/devices/update", v("json", AppDeviceMutationSchema), async (c) => {
       const input = c.req.valid("json");
-      await service.mutateDevice(await actor(c), input.deviceId, input.operation === "rename" ? input.name : undefined);
+      const result = await service.mutateDevice(
+        await actor(c),
+        input.deviceId,
+        input.operation === "rename" ? input.name : undefined,
+        input.operation === "revoke" ? input.endSessions : undefined,
+      );
+      return result ? c.json(result) : c.body(null, 204);
+    })
+    .post("/manage/device-changes/status", v("json", AppDeviceChangeLookupSchema), async (c) => {
+      return c.json(await service.findRemoval(await actor(c), c.req.valid("json")));
+    })
+    .post("/manage/device-changes/cancel", v("json", AppDeviceChangeReferenceSchema), async (c) => {
+      await service.cancelChange(await actor(c), c.req.valid("json").changeId);
       return c.body(null, 204);
     })
     .post(
@@ -118,6 +143,7 @@ export const createAppApprovalRoutes = (service: Service = appApproval, actions
             c.req.valid("json"),
             actions((appId, locale) => appNameIn(c, appId, locale, appId)),
             terminal,
+            { address: clientIp(c) },
           ),
         ),
     )
@@ -127,7 +153,10 @@ export const createAppApprovalRoutes = (service: Service = appApproval, actions
       v("json", AppLoginStartSchema),
       async (c) => {
         const input = c.req.valid("json");
-        return c.json(await service.startLogin(input.identifier, input.category), 202);
+        const description = describeRequest(c);
+        const cookie = readBrowserCookie(c);
+        const prefix = addressPrefix(clientIp(c));
+        return c.json(await service.startLogin(input.identifier, input.category, { ...description, cookie, prefix }), 202);
       },
     )
     .post("/login/status", v("json", AppLoginReferenceSchema), async (c) => {
@@ -143,8 +172,20 @@ export const createAppApprovalRoutes = (service: Service = appApproval, actions
       v("json", AppLoginReferenceSchema),
       async (c) => {
         const input = c.req.valid("json");
-        const userId = await service.consumeLogin(input.requestId, input.browserSecret);
-        await auth.session.create(c, userId);
+        const { userId, authEpoch, deviceId, deviceName } = await service.consumeLogin(input.requestId, input.browserSecret);
+        try {
+          await auth.session.create(c, userId, {
+            method: "cloud_login",
+            device: deviceName,
+            notify: options.notify,
+            authEpoch,
+            appDeviceId: deviceId,
+          });
+        } catch (error) {
+          if (error instanceof SessionEpochChangedError || error instanceof SessionAppDeviceInactiveError)
+            throw new AppApprovalError("CONFLICT", 409);
+          throw error;
+        }
         return c.body(null, 204);
       },
     );

package/src/api/approvals-loader.ts

@@ -1,9 +1,12 @@
 import type { Context } from "hono";
 import { HTTPException } from "hono/http-exception";
+import { listCapabilities } from "../_internal/registry";
 import { resolveAiChatRequestContext } from "../ai/request-context";
 import type { ApprovalListQuery, ApprovalPage } from "../contracts/approvals";
+import { CapabilityActionCallReviewSchema, capabilityActionPolicy } from "../contracts/capabilities";
 import type { AuthContext } from "../server/middleware/auth";
 import { listPending, presentPendingApproval } from "../services/approvals/list";
+import { logger } from "../services/logging";
 import { getLocalizedRuntimeContext } from "../ssr/runtime";
 
 export const loadPendingApprovals = async <T extends AuthContext>(c: Context<T>, query: ApprovalListQuery): Promise<ApprovalPage> => {
@@ -11,5 +14,24 @@ export const loadPendingApprovals = async <T extends AuthContext>(c: Context<T>,
   if (ctx instanceof Response) throw new HTTPException(403, { res: ctx });
   const page = await listPending({ approverUserId: ctx.ownerUserId, appId: query.app, link: query.link, cursor: query.cursor });
   const apps = getLocalizedRuntimeContext(c).apps;
-  return { ...page, items: page.items.map((row) => presentPendingApproval(row, apps)) };
+  const needsPolicy = page.items.some((row) => {
+    if (row.storedReview && "sentence" in row.storedReview) return false;
+    const review = CapabilityActionCallReviewSchema.safeParse(row.details);
+    return review.success && !review.data.ask;
+  });
+  const capabilities = needsPolicy
+    ? await listCapabilities().catch((error: unknown) => {
+        logger("approvals").warn("Approval capability registry unavailable", {
+          error: error instanceof Error ? error.message : String(error),
+        });
+        return [];
+      })
+    : [];
+  return {
+    ...page,
+    items: page.items.map((row) => {
+      const manifest = capabilities.find((entry) => entry.appId === row.appId)?.manifest;
+      return presentPendingApproval(row, apps, manifest ? capabilityActionPolicy(manifest, row.action) : undefined);
+    }),
+  };
 };

package/src/api/approvals.ts

@@ -18,6 +18,7 @@ import { ErrorResponseSchema } from "../contracts/shared";
 import { rateLimit } from "../server";
 import { respond } from "../server/api";
 import { type AuthContext, auth } from "../server/middleware/auth";
+import { noTransform } from "../server/middleware/no-transform";
 import { jsonResponse, requiresAuth } from "../server/middleware/openapi";
 import { v } from "../server/middleware/validator";
 import { ok } from "../server/services";
@@ -26,6 +27,7 @@ import { decodeApprovalCursor } from "../services/approvals/cursor";
 import { loadPendingApprovals } from "./approvals-loader";
 
 export const approvalRoutes = new Hono<AuthContext>()
+  .use("*", noTransform())
   .use(rateLimit())
   .use(auth.requireRole("authenticated"))
   .get(