@k2b/cloud 0.38.0 → 0.40.0

package/src/ai/client/controller.ts

@@ -1,5 +1,8 @@
 import { type Accessor, createMemo, createSignal, onCleanup } from "solid-js";
 import { createStore, reconcile } from "solid-js/store";
+import { z } from "zod";
+import { CapabilityActionReceiptSchema } from "../../contracts/capabilities";
+import { type AiActionCheck, preferredActionCheck } from "../action-review";
 import { type AiAttachmentRef, aiAttachmentMarker } from "../attachments";
 import { aiChatMessages } from "../chat/messages";
 import { AI_TURN_LEASE_MS, type AiStreamEvent, type AiTurnBlock, type AiTurnSnapshot, steerMessageBlockId } from "../protocol";
@@ -1349,6 +1352,61 @@ export const createAiChatController = (options: CreateAiChatControllerOptions) =
     return submitted;
   };
 
+  const checkAction = async (requestInput: { turnId: string; callId: string }): Promise<AiActionCheck> => {
+    const conversationId = activeConversationId();
+    if (!conversationId) throw new Error("No active conversation.");
+    const check = z
+      .object({
+        state: z.enum(["checking", "done", "not_done", "pending", "failed"]),
+        receipt: CapabilityActionReceiptSchema.optional(),
+        at: z.iso.datetime().optional(),
+      })
+      .strict()
+      .parse(
+        await request<unknown>(
+          `/conversations/${encodeURIComponent(conversationId)}/turns/${encodeURIComponent(requestInput.turnId)}/calls/${encodeURIComponent(requestInput.callId)}/check`,
+          { method: "POST" },
+          "Failed to check the Action outcome",
+        ),
+      );
+    const projection = isActiveConversation(conversationId) ? state : cache.get(conversationId);
+    let effective = check;
+    if (projection) {
+      const storedMessage = projection.messages.find(
+        (message) =>
+          message.loopId === requestInput.turnId &&
+          message.message.role === "assistant" &&
+          message.message.content.some((block) => block.type === "tool_call" && block.id === requestInput.callId),
+      );
+      const liveBlock =
+        projection.activeTurn?.turnId === requestInput.turnId
+          ? projection.activeTurn.blocks.find((block) => block.kind === "tool" && block.callId === requestInput.callId)
+          : undefined;
+      effective = preferredActionCheck(storedMessage?.meta?.toolChecks?.[requestInput.callId], effective);
+      effective = preferredActionCheck(liveBlock?.kind === "tool" ? liveBlock.check : undefined, effective);
+      const messages = projection.messages.map((message) =>
+        message.loopId === requestInput.turnId &&
+        message.message.role === "assistant" &&
+        message.message.content.some((block) => block.type === "tool_call" && block.id === requestInput.callId)
+          ? { ...message, meta: { ...message.meta, toolChecks: { ...message.meta?.toolChecks, [requestInput.callId]: effective } } }
+          : message,
+      );
+      const activeTurn =
+        projection.activeTurn?.turnId === requestInput.turnId
+          ? {
+              ...projection.activeTurn,
+              blocks: projection.activeTurn.blocks.map((block) =>
+                block.kind === "tool" && block.callId === requestInput.callId ? { ...block, check: effective } : block,
+              ),
+            }
+          : projection.activeTurn;
+      const next = { ...projection, messages, activeTurn };
+      cache.set(conversationId, next);
+      if (isActiveConversation(conversationId)) setState(reconcile(next));
+    }
+    return effective;
+  };
+
   const submitFrontendToolResult = async (request: { turnId: string; callId: string }, result: unknown) => {
     const conversationId = activeConversationId();
     if (!conversationId) return false;
@@ -1412,6 +1470,7 @@ export const createAiChatController = (options: CreateAiChatControllerOptions) =
     clearMessageFeedback,
     submitTurnAction,
     respondToApproval,
+    checkAction,
     submitFrontendToolResult,
     fileContentUrl,
   };

package/src/ai/default-tools.ts

@@ -59,7 +59,7 @@ import {
 import { createCloudAiMarkdownToPdfTool } from "./markdown-pdf-tool";
 import { createAiTodoTool } from "./todo-tool";
 import { defineAiTool } from "./tools";
-import type { AiDataBoundary, AiRuntimeTool } from "./types";
+import type { AiChatTurnRunConfig, AiDataBoundary, AiRuntimeTool } from "./types";
 import { createCloudAiViewImageTool } from "./vision-tool";
 
 export {
@@ -276,6 +276,14 @@ export const createCloudAiCodeTools = () => [
   }).server(runManagedCodeTool("code_export")),
 ];
 
+/** Server-run Code Mode and declared client tools, excluding app opening and secret entry under a mandate. */
+export const createAiTurnCodeAndClientTools = (config: Pick<AiChatTurnRunConfig, "clientToolIds" | "mandate">) =>
+  [createCloudAiLocalBashTool(), ...createCloudAiLocalTools(), ...createCloudAiCodeTools()].filter(
+    (tool) =>
+      (tool.location === "server" || config.clientToolIds?.some((name) => name === tool.def.name)) &&
+      !(config.mandate && ["code_open", "code_secret"].includes(tool.def.name)),
+  );
+
 export const createDefaultCloudAiTools = () => [
   createAiTodoTool(),
   createCloudAiSurveyTool(),

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

@@ -2,6 +2,7 @@ export { type AiAppSkillIssue, aiAppSkills, appSkillsRegistryState, reconcileApp
 export { type AiApprovalPreferenceRoutes, type AiApprovalPreferenceView, createAiApprovalPreferenceRoutes } from "./approval-routes";
 export {
   AI_WEBSITE_APPROVAL_TOOL,
+  type AiToolApprovalChangeContext,
   type AiToolApprovalContext,
   type AiToolApprovalPreference,
   type AiToolApprovalRemember,
@@ -21,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";
@@ -33,11 +35,22 @@ export {
   ChatTaskOccurrenceIdSchema,
   ChatTaskScheduleInputSchema,
   chatTaskCreateFingerprint,
+  chatTaskName,
   getChatTaskTimezone,
   normalizeChatTaskSchedule,
   toAiChatTaskOccurrenceView,
   toAiChatTaskView,
 } from "./chat-task-contracts";
+export {
+  CHAT_TASK_REASON_CODES,
+  type ChatTaskReason,
+  type ChatTaskReasonCode,
+  chatTaskLocale,
+  chatTaskNeedsNewTime,
+  chatTaskReasonSentence,
+  chatTaskReasonState,
+  chatTaskStopSentence,
+} from "./chat-task-reasons";
 export {
   type AiChatTask,
   AiChatTaskIdempotencyConflictError,
@@ -407,6 +420,7 @@ export type {
   AiProjectPromptSnapshot,
   AiProviderId,
   AiPublicModelProfile,
+  AiRecentResource,
   AiResolvedModel,
   AiRuntimeTool,
   AiSettingsError,

package/src/ai/migrate.ts

@@ -1,6 +1,7 @@
 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";
 import { migrateAiModelAccess } from "./model-access-migrate";
 import { migrateAiQuotas } from "./quotas-migrate";
@@ -403,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.
@@ -885,6 +895,8 @@ export const migrateCloudAi = async (): Promise<void> => {
     )
   `.simple();
 
+  await sql.begin(migrateChatTaskReasons);
+
   await sql`ALTER TABLE ai.chat_tasks ADD COLUMN IF NOT EXISTS idempotency_fingerprint TEXT`.simple();
   await sql`ALTER TABLE ai.chat_tasks ADD COLUMN IF NOT EXISTS revision BIGINT NOT NULL DEFAULT 0`.simple();
   await sql`ALTER TABLE ai.chat_tasks ADD COLUMN IF NOT EXISTS mandate_id UUID`.simple();
@@ -998,6 +1010,17 @@ export const migrateCloudAi = async (): Promise<void> => {
     )
   `.simple();
 
+  await sql`
+    DO $$ BEGIN
+      IF NOT EXISTS (SELECT 1 FROM pg_constraint WHERE conname = 'ai_chat_task_occurrences_state_check'
+          AND pg_get_constraintdef(oid) LIKE '%stopped%') THEN
+        ALTER TABLE ai.chat_task_occurrences DROP CONSTRAINT IF EXISTS ai_chat_task_occurrences_state_check;
+        ALTER TABLE ai.chat_task_occurrences ADD CONSTRAINT ai_chat_task_occurrences_state_check
+          CHECK (state IN ('queued', 'running', 'completed', 'failed', 'stopped'));
+      END IF;
+    END $$
+  `.simple();
+
   await sql`ALTER TABLE ai.chat_task_occurrences ADD COLUMN IF NOT EXISTS task_revision BIGINT NOT NULL DEFAULT 0`.simple();
 
   await sql`
@@ -1016,10 +1039,18 @@ export const migrateCloudAi = async (): Promise<void> => {
     WHERE state = 'queued'
   `.simple();
 
+  await sql`
+    DO $$ BEGIN
+      IF EXISTS (SELECT 1 FROM pg_indexes WHERE schemaname = 'ai' AND indexname = 'idx_ai_chat_task_occurrences_finished'
+          AND indexdef NOT LIKE '%stopped%') THEN
+        DROP INDEX ai.idx_ai_chat_task_occurrences_finished;
+      END IF;
+    END $$
+  `.simple();
   await sql`
     CREATE INDEX IF NOT EXISTS idx_ai_chat_task_occurrences_finished
     ON ai.chat_task_occurrences(completed_at, id)
-    WHERE state IN ('completed', 'failed')
+    WHERE state IN ('completed', 'failed', 'stopped')
   `.simple();
 
   await sql`
@@ -2468,7 +2499,11 @@ export const migrateCloudAi = async (): Promise<void> => {
   {
     const { coreSettings } = await import("../services");
     const { setAiCredential, splitAiProfileCredentials } = await import("./credentials");
-    const split = splitAiProfileCredentials((await coreSettings.get<string>("ai.model_profiles_json")) ?? "[]");
+    const profiles = await coreSettings.read<string>("ai.model_profiles_json");
+    if (profiles.stored === "unreadable") {
+      console.warn('[ai] cannot read setting "ai.model_profiles_json"; skipping credential split');
+    }
+    const split = profiles.stored === "unreadable" ? null : splitAiProfileCredentials(profiles.value ?? "[]");
     if (split && split.credentials.length > 0) {
       for (const { profileId, secret } of split.credentials) await setAiCredential(profileId, secret);
       await coreSettings.set("ai.model_profiles_json", split.profilesJson);
@@ -2641,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) })))