@k2b/cloud 0.39.0 → 0.40.0

package/src/ai/executor.ts

@@ -1,7 +1,9 @@
 import type { AssistantMessage, CompactEvent, LoopAggregate, Message, NessiLoop, OutboundEvent } from "@k2b/nessi";
 import { compact, nessi } from "@k2b/nessi";
+import { capabilityReviewRememberScope } from "../_internal/capability-reviews";
 import { listCapabilities } from "../_internal/registry";
-import type { CapabilityActionReview } from "../contracts/capabilities";
+import type { CapabilityActionReviewData } from "../contracts/capabilities";
+import { capabilityActionPolicy } from "../contracts/capabilities";
 import type { AccessSubject, RequestActor } from "../server";
 import { approvalAssurance, approvalScopeFromToolName, approvals } from "../services/approvals";
 import { createHelpReader } from "../services/help";
@@ -10,6 +12,7 @@ import { getMandate } from "../services/mandates";
 import type { MandatePolicyV1 } from "../services/mandates/policy";
 import { coreSettings } from "../services/settings/api";
 import { normalizeLocale } from "../shared/locale";
+import { type AiActionCheck, type AiStoredActionReview, storedActionReview } from "./action-review";
 import {
   AI_WEBSITE_APPROVAL_TOOL,
   type AiToolApprovalContext,
@@ -19,20 +22,23 @@ import {
   hasRememberedAiToolApproval,
 } from "./approvals";
 import { aiChatAccessSubject, isAssistantChatTurn, resolveAssistantAudioModel } from "./assistant-models";
+import { authorizeBackgroundActionWith } from "./background-review";
 import { CODE_RUNTIME_TOOL_NAMES } from "./browser-code-contracts";
-import { type AiCapabilityCatalogEntry, createAiToolResolver, createRunToolStore } from "./capabilities";
-import { AiCapabilityExecutionError, executeAiCapability, resolveAiCapabilityActor, reviewAiCapability } from "./capability-execution";
+import { type AiCapabilityCatalogEntry, buildAiCapabilityCatalog, createAiToolResolver, createRunToolStore } from "./capabilities";
+import {
+  AiCapabilityExecutionError,
+  aiCapabilityCheckResult,
+  checkAiCapability,
+  executeAiCapability,
+  resolveAiCapabilityActor,
+  reviewAiCapability,
+} from "./capability-execution";
 import { aiChatMessages } from "./chat/messages";
 import { isFailedTool } from "./chat/tool-groups";
 import { aiTurnErrorText } from "./chat/turn-error";
 import { AiChatTaskAuthorityError, aiChatTasks } from "./chat-tasks";
 import { createCloudCompactFn } from "./compaction";
-import {
-  createCloudAiCodeTools,
-  createCloudAiLocalBashTool,
-  createCloudAiLocalTools,
-  createConfiguredDefaultCloudAiTools,
-} from "./default-tools";
+import { createAiTurnCodeAndClientTools, createConfiguredDefaultCloudAiTools } from "./default-tools";
 import { aiFileStore } from "./files-store";
 import { AI_LOCAL_TOOL_NAMES } from "./local-tool-contracts";
 import {
@@ -72,7 +78,15 @@ import { isAiVisionModelConfigured, type resolveAiModel } from "./settings";
 import { mergeAiSkillCatalog, selectAiSkillCatalog } from "./skill-catalog";
 import { createCloudAiLoadSkillTool, createCloudAiSearchSkillsTool, loadSelectedAiSkills } from "./skill-tool";
 import { aiSkills } from "./skills";
-import { aiConversations, recordAiWebsiteReceipts } from "./store";
+import {
+  AI_TOOL_CHECK_STALE_MS,
+  aiConversations,
+  claimAiToolCheck,
+  readAiToolCheck,
+  recordAiToolReview,
+  recordAiWebsiteReceipts,
+  settleAiToolCheck,
+} from "./store";
 import { AI_LIVE_SNAPSHOT_INTERVAL_MS, publishAiWireEvent } from "./stream";
 import { composeAiSystemPrompt } from "./system-prompt";
 import { aiToolAudit } from "./tool-audit";
@@ -427,9 +441,9 @@ type ToolBlockPatch = Partial<Extract<AiTurnBlock, { kind: "tool" }>> & { name?:
 const customApprovalParentCallId = (callId: string): string | undefined => /^(.*)-approval-\d+$/.exec(callId)?.[1];
 
 const approvalReviewForCallId = (
-  reviews: ReadonlyMap<string, CapabilityActionReview>,
+  reviews: ReadonlyMap<string, CapabilityActionReviewData>,
   callId: string,
-): CapabilityActionReview | undefined => {
+): CapabilityActionReviewData | undefined => {
   const direct = reviews.get(callId);
   if (direct) return direct;
   const parentCallId = customApprovalParentCallId(callId);
@@ -479,9 +493,11 @@ const createEventMapper = (attempt: number, seedBlocks: AiTurnBlock[], allowReme
   const setCanonicalNames = (items: Map<string, string>) => {
     canonicalNames = items;
   };
-  let approvalReviews = new Map<string, CapabilityActionReview>();
-  const setApprovalReviews = (items: Map<string, CapabilityActionReview>) => {
+  let approvalReviews = new Map<string, CapabilityActionReviewData>();
+  let capabilityScopes: ReadonlyMap<string, string> = new Map();
+  const setApprovalReviews = (items: Map<string, CapabilityActionReviewData>, scopes: ReadonlyMap<string, string> = new Map()) => {
     approvalReviews = items;
+    capabilityScopes = scopes;
   };
   let approvalPolicies: PreparedAiTools["approvalPolicies"] = new Map();
   const setApprovalPolicies = (items: PreparedAiTools["approvalPolicies"]) => {
@@ -505,7 +521,7 @@ const createEventMapper = (attempt: number, seedBlocks: AiTurnBlock[], allowReme
   const streamKinds = new Map<string, "text" | "thinking">();
 
   const setTool = (callId: string, patch: ToolBlockPatch, displayCallId = callId): BlockOp => {
-    const existing = toolBlocks.get(callId);
+    const existing = toolBlocks.get(callId) ?? toolBlocks.get(displayCallId);
     const rawName = patch.name ?? existing?.name ?? "tool";
     const name = canonicalNames.get(rawName) ?? rawName;
     const approval = patch.clearApproval ? undefined : "approval" in patch ? patch.approval : existing?.approval;
@@ -520,6 +536,8 @@ const createEventMapper = (attempt: number, seedBlocks: AiTurnBlock[], allowReme
       result: "result" in patch ? patch.result : existing?.result,
       isError: "isError" in patch ? patch.isError : existing?.isError,
       approval: approval && !allowRememberedApprovals ? { ...approval, allowAlways: false, allowChat: false } : approval,
+      review: patch.review ?? existing?.review,
+      check: patch.check ?? existing?.check,
       frontendMode: patch.frontendMode ?? existing?.frontendMode,
       presentation: patch.presentation ?? existing?.presentation ?? presentations.get(rawName) ?? presentations.get(name),
       ...(approvedCallIds.has(callId) || approvedCallIds.has(displayCallId) || existing?.approved ? { approved: true } : {}),
@@ -572,7 +590,8 @@ const createEventMapper = (attempt: number, seedBlocks: AiTurnBlock[], allowReme
         const target = event.kind === "custom_approval" ? approvalTargets.get(event.callId) : undefined;
         const allowAlways = target
           ? target.always
-          : review?.approvalScope !== undefined || aiToolAllowsAlways(approvalPolicies.get(event.name));
+          : capabilityScopes.has(customApprovalParentCallId(event.callId) ?? event.callId) ||
+            aiToolAllowsAlways(approvalPolicies.get(event.name));
         return [
           setTool(
             event.callId,
@@ -651,6 +670,7 @@ const createEventMapper = (attempt: number, seedBlocks: AiTurnBlock[], allowReme
 
   return {
     translate,
+    setTool,
     storedMessage,
     compaction,
     setFrontendModes,
@@ -690,10 +710,7 @@ const materializeChatConfig = async (config: AiChatTurnRunConfig, signal: AbortS
               accessSubject: aiChatAccessSubject(config.actor),
               allowedDataBoundaries: config.modelPolicy?.allowedDataBoundaries,
             })),
-            // Cloud runs the code tools itself; only tools a client must run wait for that client to declare them.
-            ...[createCloudAiLocalBashTool(), ...createCloudAiLocalTools(), ...createCloudAiCodeTools()].filter(
-              (tool) => tool.location === "server" || config.clientToolIds?.some((name) => name === tool.def.name),
-            ),
+            ...createAiTurnCodeAndClientTools(config),
           ]
         : [],
     toolApprovalContext: config.toolApprovalContext,
@@ -997,11 +1014,7 @@ export class AiTurnExecutor {
     ];
     const toolsSupported = resolved.profile.capabilities.includes("tools");
     const allowed = allowedTools === null ? null : new Set(allowedTools);
-    const activeTools = toolsSupported
-      ? runtimeTools.filter(
-          (tool) => (!allowed || allowed.has(tool.def.name)) && !(config.mandate && ["code_open", "code_secret"].includes(tool.def.name)),
-        )
-      : [];
+    const activeTools = toolsSupported ? runtimeTools.filter((tool) => !allowed || allowed.has(tool.def.name)) : [];
     let audioUnavailableInstruction: string | undefined;
     if (
       defaultToolSource &&
@@ -1092,7 +1105,23 @@ export class AiTurnExecutor {
     });
     let backgroundError: string | null = null;
     const rememberableCapabilityApprovals = new Map<string, string>();
-    const capabilityActionReviews = new Map<string, CapabilityActionReview>();
+    const capabilityActionReviews = new Map<string, CapabilityActionReviewData>();
+    const storedReviews = new Map<string, AiStoredActionReview>();
+    const onCapabilityReview = async (
+      callId: string,
+      review: CapabilityActionReviewData,
+      approval: "none" | "rememberable" | undefined,
+      entry: AiCapabilityCatalogEntry,
+    ) => {
+      capabilityActionReviews.set(callId, review);
+      const scope = capabilityReviewRememberScope(review, approval);
+      if (scope) rememberableCapabilityApprovals.set(callId, scope);
+      else rememberableCapabilityApprovals.delete(callId);
+      const stored = storedActionReview(review, capabilityActionPolicy(entry.app.manifest, entry.operation.localId));
+      await recordAiToolReview({ conversationId, turnId, callId, review: stored });
+      storedReviews.set(callId, stored);
+      await pipeline.setToolReview(callId, stored);
+    };
     pipeline.setApprovalTargets(approvalTargets);
     pipeline.setFrontendModes(prepared.frontendModes);
     pipeline.setCanonicalNames(prepared.canonicalNames);
@@ -1101,7 +1130,7 @@ export class AiTurnExecutor {
     const rejectedToolCallIds = new Set<string>();
     const approvedToolCallIds = new Set<string>();
     pipeline.setPresentations(toolPresentations);
-    pipeline.setApprovalReviews(capabilityActionReviews);
+    pipeline.setApprovalReviews(capabilityActionReviews, rememberableCapabilityApprovals);
     let turnInput = config.input;
     try {
       if (resolved.profile.capabilities.includes("vision") && config.files?.attached.some((file) => isAiImageMediaType(file.mediaType))) {
@@ -1192,7 +1221,7 @@ export class AiTurnExecutor {
       );
       return;
     }
-    const authorizeBackground =
+    const authorizeBackgroundMandate =
       config.background && config.mandate
         ? async (entry: AiCapabilityCatalogEntry, args: unknown) => {
             try {
@@ -1202,6 +1231,7 @@ export class AiTurnExecutor {
                 capabilityId: entry.operation.localId,
                 kind: entry.kind,
                 input: args,
+                policy: capabilityActionPolicy(entry.app.manifest, entry.operation.localId),
                 approval: entry.kind === "action" && "approval" in entry.operation ? entry.operation.approval : undefined,
               });
             } catch (error) {
@@ -1245,16 +1275,51 @@ export class AiTurnExecutor {
                   }),
               }
             : {}),
-          authorizeBackground,
-          onReview: (callId, review) => {
-            capabilityActionReviews.set(callId, review);
-            if (review.approvalScope) rememberableCapabilityApprovals.set(callId, review.approvalScope);
-          },
+          authorizeBackground: authorizeBackgroundMandate
+            ? async (entry, args, context) => {
+                const review = await authorizeBackgroundActionWith(
+                  {
+                    turnId,
+                    mandate: config.mandate!,
+                    appId: entry.appId,
+                    capabilityId: entry.operation.localId,
+                    kind: entry.kind,
+                    args,
+                    policy: capabilityActionPolicy(entry.app.manifest, entry.operation.localId),
+                    approval: entry.kind === "action" && "approval" in entry.operation ? entry.operation.approval : undefined,
+                    hasReview: entry.kind === "action" && "review" in entry.operation && entry.operation.review === true,
+                    action: entry.display.title,
+                    review: () =>
+                      capabilityAuthority
+                        ? reviewAiCapability({
+                            conversationId,
+                            authority: capabilityAuthority,
+                            mandate: config.mandate,
+                            locale: promptLocale,
+                            entry,
+                            args,
+                            context,
+                          })
+                        : Promise.resolve(null),
+                    signal: context.signal,
+                  },
+                  () => authorizeBackgroundMandate(entry, args),
+                );
+                if (review && context.callId)
+                  await onCapabilityReview(
+                    context.callId,
+                    review,
+                    "approval" in entry.operation ? entry.operation.approval : undefined,
+                    entry,
+                  );
+              }
+            : undefined,
+          onReview: onCapabilityReview,
           ...(capabilityAuthority
             ? {
                 execute: async (entry, args, context) => {
                   try {
-                    await authorizeBackground?.(entry, args);
+                    await authorizeBackgroundMandate?.(entry, args);
                     const result = await executeAiCapability({
                       conversationId,
                       turnId,
@@ -1268,9 +1333,78 @@ export class AiTurnExecutor {
                       entry,
                       args,
                       context,
+                    }).catch(async (error: unknown) => {
+                      const review = context.callId ? storedReviews.get(context.callId) : undefined;
+                      if (entry.kind !== "action" || !(error instanceof AiCapabilityExecutionError)) throw error;
+                      // Only an answer from the app about the request itself (a 4xx) proves that nothing happened. A 5xx,
+                      // a timeout, or a cancellation leaves the outcome open only once Cloud sent the request to the app;
+                      // before that, nothing ran and the error stays as it is. The idempotency codes speak of an earlier
+                      // attempt with the same key, so they leave it open even when this one sent nothing.
+                      const uncertain =
+                        ["ACTION_OUTCOME_UNKNOWN", "IDEMPOTENCY_UNCERTAIN", "IDEMPOTENCY_IN_PROGRESS"].includes(error.code) ||
+                        (error.dispatched && (error.status >= 500 || error.status === 499));
+                      if (!uncertain) throw error;
+                      const unknown =
+                        error.code === "ACTION_OUTCOME_UNKNOWN"
+                          ? error
+                          : new AiCapabilityExecutionError(
+                              "ACTION_OUTCOME_UNKNOWN",
+                              error.status,
+                              `The outcome is unknown after ${error.code}; do not retry automatically.`,
+                              error.dispatched,
+                            );
+                      if (!review || !("sentence" in review) || !review.check || !context.callId) throw unknown;
+                      let check: AiActionCheck;
+                      try {
+                        // Durable first: the claim stores `checking` before the Query runs. If this worker stops, the
+                        // claim goes stale and the person can check again; while it holds, no re-check runs beside it.
+                        const target = { conversationId, turnId, callId: context.callId };
+                        const claimedAt = new Date().toISOString();
+                        const claimed = await claimAiToolCheck({
+                          ...target,
+                          at: claimedAt,
+                          staleBefore: new Date(Date.now() - AI_TOOL_CHECK_STALE_MS).toISOString(),
+                          first: true,
+                        });
+                        if (!claimed) {
+                          // A person's check holds or settled the call already; its stored result is the outcome.
+                          const stored = await readAiToolCheck(target);
+                          const known = stored && stored.state !== "checking" ? stored : { state: "pending" as const };
+                          check = known;
+                        } else {
+                          await pipeline.setToolCheck(context.callId, { state: "checking" });
+                          const answered = await checkAiCapability({
+                            conversationId,
+                            turnId,
+                            authority: capabilityAuthority!,
+                            mandate: config.mandate,
+                            // The receipt joins the review's sentence, so it is asked for in the review's language.
+                            locale: review.locale,
+                            entry,
+                            check: review.check,
+                            catalog: buildAiCapabilityCatalog([entry.app], promptLocale),
+                            context,
+                          });
+                          // A claim that went stale and was taken over loses to the newer check's stored result.
+                          check = (await settleAiToolCheck({ ...target, claimedAt, check: answered }))
+                            ? answered
+                            : ((await readAiToolCheck(target)) ?? answered);
+                        }
+                        await pipeline.setToolCheck(context.callId, check);
+                      } catch (recoveryError) {
+                        log.warn("AI Action outcome recovery failed", {
+                          code: "action_outcome_recovery_failed",
+                          turnId,
+                          callId: context.callId,
+                          error: recoveryError instanceof Error ? recoveryError.message : String(recoveryError),
+                        });
+                        throw unknown;
+                      }
+                      return aiCapabilityCheckResult(check);
                     });
                     const resources = collectConversationResourceObservations(args, result);
                     if (resources.length) {
+                      // Bookkeeping after a call that ran never turns its outcome into a failure: the effect happened.
                       await Promise.all([
                         indexConversationResources({ conversationId, turnId, callId: context.callId, resources }),
                         recordMemoryWorkflowEvidence({
@@ -1280,7 +1414,14 @@ export class AiTurnExecutor {
                           capabilityId: entry.name,
                           resources,
                         }),
-                      ]);
+                      ]).catch((error: unknown) =>
+                        log.warn("AI capability bookkeeping failed after the call ran", {
+                          code: "capability_bookkeeping_failed",
+                          turnId,
+                          callId: context.callId,
+                          error: error instanceof Error ? error.message : String(error),
+                        }),
+                      );
                     }
                     return result;
                   } catch (error) {
@@ -1593,7 +1734,7 @@ export class AiTurnExecutor {
     approvalContext?: AiToolApprovalContext;
     allowRememberedApprovals: boolean;
     rememberableCapabilityApprovals: ReadonlyMap<string, string>;
-    capabilityActionReviews: ReadonlyMap<string, CapabilityActionReview>;
+    capabilityActionReviews: ReadonlyMap<string, CapabilityActionReviewData>;
     approvalTargets: ReadonlyMap<string, AiApprovalTarget>;
     linkedApprovals: ReadonlyMap<string, string>;
     freshApprovalRequired?: ReadonlySet<string>;
@@ -1778,7 +1919,7 @@ export class AiTurnExecutor {
     approvalContext?: AiToolApprovalContext;
     allowRememberedApprovals: boolean;
     rememberableCapabilityApprovals: ReadonlyMap<string, string>;
-    capabilityActionReviews: ReadonlyMap<string, CapabilityActionReview>;
+    capabilityActionReviews: ReadonlyMap<string, CapabilityActionReviewData>;
     approvalTargets: ReadonlyMap<string, AiApprovalTarget>;
     linkedApprovals: ReadonlyMap<string, string>;
     freshApprovalRequired?: ReadonlySet<string>;
@@ -2207,8 +2348,8 @@ class StreamPipeline {
     this.mapper.setCanonicalNames(names);
   }
 
-  setApprovalReviews(reviews: Map<string, CapabilityActionReview>): void {
-    this.mapper.setApprovalReviews(reviews);
+  setApprovalReviews(reviews: Map<string, CapabilityActionReviewData>, scopes: ReadonlyMap<string, string>): void {
+    this.mapper.setApprovalReviews(reviews, scopes);
   }
 
   setApprovalPolicies(policies: PreparedAiTools["approvalPolicies"]): void {
@@ -2290,6 +2431,16 @@ class StreamPipeline {
     await this.maybeSnapshot();
   }
 
+  async setToolReview(callId: string, review: AiStoredActionReview): Promise<void> {
+    await this.emitOp(this.mapper.setTool(callId, { review }));
+    await this.maybeSnapshot();
+  }
+
+  async setToolCheck(callId: string, check: AiActionCheck): Promise<void> {
+    await this.emitOp(this.mapper.setTool(callId, { check, status: "running" }));
+    await this.maybeSnapshot();
+  }
+
   async reportToolProgress(callId: string, progress: string): Promise<void> {
     const block = this.blocks.find((block) => block.kind === "tool" && block.callId === callId);
     if (!block || block.kind !== "tool" || block.progress === progress) return;

package/src/ai/index.ts

@@ -22,6 +22,7 @@ export {
 export { assistantAiSettingsState, listAssistantAiModels, selectAssistantAiModelId } from "./assistant-models";
 export { type AiAttachmentRef, aiAttachmentMarker, formatAiFileSize, parseAiAttachmentMarkers } from "./attachments";
 export { CloudAiTranscribeAudioInputSchema, CloudAiTranscribeAudioOutputSchema, createCloudAiTranscribeAudioTool } from "./audio-tool";
+export { AiBackgroundApprovalRequiredError, authorizeBackgroundAction } from "./background-review";
 export { CODE_RUNTIME_TOOL_NAMES, CodeResourceId, CodeRuntimeInput, parseCodeToolInput } from "./browser-code-contracts";
 export { aiCapabilityId, aiCapabilityToolName } from "./capabilities";
 export { getAiChatQuotas } from "./chat-quotas";
@@ -419,6 +420,7 @@ export type {
   AiProjectPromptSnapshot,
   AiProviderId,
   AiPublicModelProfile,
+  AiRecentResource,
   AiResolvedModel,
   AiRuntimeTool,
   AiSettingsError,

package/src/ai/migrate.ts

@@ -1,5 +1,5 @@
 import { sql } from "bun";
-import { CapabilityActionReviewSchema } from "../contracts/capabilities";
+import { CapabilityActionReviewDataSchema } from "../contracts/capabilities";
 import { APPROVAL_MAX_WAIT_MS, approvalAssurance, approvalScopeFromToolName, approvals, migrateApprovals } from "../services/approvals";
 import { migrateChatTaskReasons } from "./chat-task-reasons-migrate";
 import { migrateAiMessageQueue } from "./message-queue";
@@ -404,6 +404,15 @@ export const migrateCloudAi = async (): Promise<void> => {
     ON ai.messages(conversation_id, loop_id, seq ASC)
     WHERE loop_id IS NOT NULL
   `.simple();
+  // "Recent" in the slash menu reads the newest messages a person sent in each of their latest chats. Without it the
+  // read walks every Assistant and tool row of those chats. The predicate matches the store query word for word.
+  await sql`
+    CREATE INDEX IF NOT EXISTS idx_ai_messages_sent_by_person
+    ON ai.messages(conversation_id, seq DESC) INCLUDE (created_at, id)
+    WHERE role = 'user' AND kind = 'message'
+      AND NOT (COALESCE(meta, '{}'::jsonb) ? 'scheduledTask')
+      AND NOT (COALESCE(meta, '{}'::jsonb) ? 'agentMessage')
+  `.simple();
 
   // Optional pg_textsearch ranking. Native weighted FTS above is always the
   // correctness path; missing extension support must never block startup.
@@ -2667,7 +2676,7 @@ const backfillApprovalRequests = async (): Promise<void> => {
             WHERE r.requester_kind='assistant_turn' AND r.requester_ref=a.turn_id::text || '/' || a.call_id)
         ORDER BY a.created_at, a.id LIMIT 200 FOR UPDATE OF a SKIP LOCKED`;
       for (const row of rows) {
-        const review = CapabilityActionReviewSchema.safeParse(row.review == null ? null : decoded(row.review));
+        const review = CapabilityActionReviewDataSchema.safeParse(row.review == null ? null : decoded(row.review));
         // request computes both canonical digests; preserve the original wait deadline, including expiry.
         const record = await approvals.request(
           {

package/src/ai/projects-routes.ts

@@ -4,6 +4,7 @@ import { getCapability } from "../_internal/registry";
 import { CloudResourceRefSchema, cloudResourceRefAppId, resolveCapabilityResourceReader } from "../contracts/capabilities";
 import { AuthenticatedPrincipalSchema } from "../contracts/shared";
 import { type AuthContext, auth, err, fail, getLocale, ok, rateLimit, respond, v } from "../server";
+import { noTransform } from "../server/middleware/no-transform";
 import { ImageMetadataError } from "../services/image-metadata";
 import { aiChatMessages } from "./chat/messages";
 import { decodeAiFileContent } from "./files-store";
@@ -71,6 +72,8 @@ type AiProjectsRouteDependencies = {
 
 const buildAiProjectsRoutes = (dependencies: AiProjectsRouteDependencies = {}) =>
   new Hono<AuthContext>()
+    // The list combines projects from separate grants; the writer of one can rename it next to another project's instructions.
+    .use("*", noTransform())
     .use(dependencies.limit ?? rateLimit())
     .use("*", dependencies.authenticate ?? auth.requireRole("authenticated"))
     .get("/", async (c) => respond(c, ok({ projects: (await aiProjects.list(c.get("accessSubject") ?? null)).map(publicProject) })))

package/src/ai/protocol.ts

@@ -1,5 +1,6 @@
 import type { CompactResult, InboundEvent, Message } from "@k2b/nessi";
-import type { CapabilityActionReview } from "../contracts/capabilities";
+import type { CapabilityActionReviewData } from "../contracts/capabilities";
+import type { AiActionCheck, AiStoredActionReview } from "./action-review";
 import type { AiConversation, AiFrontendToolMode, AiStoredMessage, AiToolPresentation, AiTurnStatus } from "./types";
 
 /**
@@ -48,7 +49,7 @@ export type AiTurnBlock =
       /** Present while status is awaiting_approval. */
       approval?: {
         message?: string;
-        review?: CapabilityActionReview;
+        review?: CapabilityActionReviewData;
         allowAlways: boolean;
         /** Whether the approval can be remembered for this chat. */
         allowChat?: boolean;
@@ -66,6 +67,13 @@ export type AiTurnBlock =
       presentation?: AiToolPresentation;
       /** Requests a website approval let through without asking, in order; shown whatever the call's outcome. */
       receipts?: { method: string; url: string }[];
+      /**
+       * The call's review as Cloud stored it when the app reviewed it. It stays after the decision, so the question,
+       * its receipt, and a reload all read the same sentence.
+       */
+      review?: AiStoredActionReview;
+      /** The app's `check` after an outcome Cloud could not see. */
+      check?: AiActionCheck;
     }
   | { id: string; kind: "compaction"; status: "running" | "completed" | "skipped" | "failed"; result?: CompactResult };
 
@@ -248,6 +256,8 @@ export const buildBlocksFromMessages = (
     meta?: {
       steerId?: string;
       toolPresentations?: Record<string, AiToolPresentation>;
+      toolReviews?: Record<string, AiStoredActionReview>;
+      toolChecks?: Record<string, AiActionCheck>;
       toolOutcomes?: Record<string, "rejected" | "approved" | "expired">;
       websiteReceipts?: Record<string, Record<string, { method: string; url: string }>>;
     } | null;
@@ -275,6 +285,8 @@ export const buildBlocksFromMessages = (
             args: block.args,
             status: "running",
             presentation: meta?.toolPresentations?.[block.id],
+            review: meta?.toolReviews?.[block.id],
+            check: meta?.toolChecks?.[block.id],
             // A turn that ended before an approved call returned records the approval on the call's message, and an
             // approval it left waiting as expired.
             ...(outcome === "approved" || outcome === "expired" ? { approved: outcome === "approved" } : {}),