@k2b/cloud 0.24.0 → 0.26.0

package/src/ai/client/projection.ts

@@ -9,6 +9,14 @@ export type AiActiveTurn = {
   status: "running" | "waiting_for_action";
   blocks: AiTurnBlock[];
   modelProfileId: string | null;
+  /** A model call failed transiently and waits for its retry. Live only: the next turn event or a snapshot ends it. */
+  providerRetry?: boolean;
+  /** Server start of the turn, known from a state snapshot. */
+  createdAt?: string;
+  /** Time already spent waiting for answered user actions, from the last state snapshot. */
+  actionWaitMs?: number;
+  /** Start of the user action the turn waited for at the last state snapshot. */
+  waitingSince?: string | null;
 };
 
 export type AiChatProjection = {
@@ -90,7 +98,7 @@ export const mergeActiveTurn = (previous: AiActiveTurn | null, incoming: AiActiv
   const pendingSteers = previous.blocks.filter((block) => block.kind === "steer_message" && block.status !== "consumed");
   const known = new Set(incoming.blocks.map((block) => block.id));
   const blocks = [...incoming.blocks, ...pendingSteers.filter((block) => !known.has(block.id))];
-  return { ...incoming, blocks, status: deriveStatus(blocks) };
+  return { ...turnTiming(previous), ...incoming, blocks, status: deriveStatus(blocks) };
 };
 
 export const reconcileActiveTurnActions = (
@@ -112,9 +120,22 @@ export const activeTurnFromSnapshot = (snapshot: AiTurnSnapshot | null): AiActiv
     status: snapshot.status === "waiting_for_action" ? "waiting_for_action" : "running",
     blocks: normalizeCustomApprovalBlocks(snapshot.blocks),
     modelProfileId: snapshot.modelProfileId,
+    createdAt: snapshot.createdAt,
+    ...(snapshot.actionWaitMs !== undefined ? { actionWaitMs: snapshot.actionWaitMs } : {}),
+    ...(snapshot.waitingSince !== undefined ? { waitingSince: snapshot.waitingSince } : {}),
   };
 };
 
+/** Snapshot timing survives later attempts of the same turn, which carry no timing of their own. */
+const turnTiming = (turn: AiActiveTurn | null | undefined): Pick<AiActiveTurn, "createdAt" | "actionWaitMs" | "waitingSince"> =>
+  turn
+    ? {
+        ...(turn.createdAt !== undefined ? { createdAt: turn.createdAt } : {}),
+        ...(turn.actionWaitMs !== undefined ? { actionWaitMs: turn.actionWaitMs } : {}),
+        ...(turn.waitingSince !== undefined ? { waitingSince: turn.waitingSince } : {}),
+      }
+    : {};
+
 /**
  * Fold one stream event into the projection. Pure and total: the client and any
  * test converge on the same state for the same ordered event sequence.
@@ -125,6 +146,7 @@ export const activeTurnFromSnapshot = (snapshot: AiTurnSnapshot | null): AiActiv
  *   stale attempts are ignored. Older senders without a baseline reset to only
  *   locally pending steering blocks.
  * - block events apply only when strictly newer than the active turn's cursor.
+ * - `provider_retry` marks the active turn until its next event.
  * - `turn_finished` folds the turn's persisted messages in and clears the active turn.
  */
 export const reduceProjection = (state: AiChatProjection, event: AiStreamEvent): AiChatProjection => {
@@ -146,6 +168,8 @@ export const reduceProjection = (state: AiChatProjection, event: AiStreamEvent):
   return reduceWireEvent(state, event);
 };
 
+const withoutProviderRetry = ({ providerRetry: _, ...turn }: AiActiveTurn): AiActiveTurn => turn;
+
 export const reduceWireEvent = (state: AiChatProjection, event: AiWireEvent): AiChatProjection => {
   const active = state.activeTurn;
 
@@ -163,6 +187,7 @@ export const reduceWireEvent = (state: AiChatProjection, event: AiWireEvent): Ai
         status: deriveStatus(blocks),
         blocks,
         modelProfileId: event.modelProfileId,
+        ...turnTiming(active?.turnId === event.turnId ? active : null),
       },
     };
   }
@@ -172,20 +197,26 @@ export const reduceWireEvent = (state: AiChatProjection, event: AiWireEvent): Ai
     return { ...state, messages: mergeMessages(state.messages, event.messages ?? []), activeTurn: null };
   }
 
+  if (!active || active.turnId !== event.turnId || !isNewerWireEvent(event, active)) return state;
+
+  if (event.type === "provider_retry") {
+    return { ...state, activeTurn: { ...active, seq: event.seq, attempt: event.attempt, providerRetry: true } };
+  }
+
   if (event.type === "message_saved") {
-    if (!active || active.turnId !== event.turnId || !isNewerWireEvent(event, active)) return state;
     return {
       ...state,
       messages: mergeMessages(state.messages, [event.message]),
-      activeTurn: { ...active, seq: event.seq, attempt: event.attempt },
+      activeTurn: { ...withoutProviderRetry(active), seq: event.seq, attempt: event.attempt },
     };
   }
 
   // block_set / block_delta
-  if (!active || active.turnId !== event.turnId) return state;
-  if (!isNewerWireEvent(event, active)) return state;
   const blocks = applyWireEventToBlocks(active.blocks, event);
-  return { ...state, activeTurn: { ...active, attempt: event.attempt, seq: event.seq, blocks, status: deriveStatus(blocks) } };
+  return {
+    ...state,
+    activeTurn: { ...withoutProviderRetry(active), attempt: event.attempt, seq: event.seq, blocks, status: deriveStatus(blocks) },
+  };
 };
 
 /** Assistant/tool messages of the active turn are represented by live blocks; hide them. */

package/src/ai/executor.ts

@@ -40,6 +40,7 @@ import {
   streamBlockId,
   toolBlockId,
 } from "./protocol";
+import { retryTransientProviderErrors } from "./provider-retry";
 import { assistantQuotaProvider, inferenceProvider } from "./quota-provider";
 import { collectConversationResourceObservations } from "./resource-refs";
 import { AiRunTimeout } from "./run-timeout";
@@ -249,6 +250,8 @@ export type ExecutorConfig = {
   validateTurn?: typeof validateAiTurnRequest;
   /** Runs after the durable turn state and final wire event are flushed. */
   onTurnFinalized?: (event: AiTurnFinalizedEvent) => Promise<void>;
+  /** Waits before retrying a transient provider failure without Retry-After; tests shorten them. */
+  providerRetryDelaysMs?: readonly number[];
 };
 
 type ResolvedModel = Awaited<ReturnType<typeof resolveAiModel>>;
@@ -392,6 +395,10 @@ const createEventMapper = (attempt: number, seedBlocks: AiTurnBlock[], allowReme
   const setRejectedCallIds = (items: Set<string>) => {
     rejectedCallIds = items;
   };
+  let approvedCallIds = new Set<string>();
+  const setApprovedCallIds = (items: Set<string>) => {
+    approvedCallIds = items;
+  };
   /** nessi stream block ids (turn-scoped) that belong to tool_call blocks — their deltas are raw args JSON. */
   const toolStreamIds = new Set<string>();
   /** kind per open Cloud stream block id, for delta create-if-missing. */
@@ -414,6 +421,7 @@ const createEventMapper = (attempt: number, seedBlocks: AiTurnBlock[], allowReme
       approval: approval && !allowRememberedApprovals ? { ...approval, allowAlways: false } : approval,
       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 } : {}),
     };
     toolBlocks.set(callId, block);
     return { type: "block_set", block };
@@ -518,6 +526,7 @@ const createEventMapper = (attempt: number, seedBlocks: AiTurnBlock[], allowReme
     setApprovalPolicies,
     setApprovalReviews,
     setRejectedCallIds,
+    setApprovedCallIds,
   };
 };
 
@@ -829,6 +838,7 @@ export class AiTurnExecutor {
     pipeline.setApprovalPolicies(prepared.approvalPolicies);
     const toolPresentations = new Map<string, AiToolPresentation>();
     const rejectedToolCallIds = new Set<string>();
+    const approvedToolCallIds = new Set<string>();
     pipeline.setPresentations(toolPresentations);
     pipeline.setApprovalReviews(capabilityActionReviews);
     let turnInput = config.input;
@@ -868,17 +878,19 @@ export class AiTurnExecutor {
       turnInput,
       toolPresentations,
       rejectedToolCallIds,
+      approvedToolCallIds,
     });
 
     const { loopMessages, pendingRecords, resolvedRecords, turnSteers } =
       attemptState ?? (await loadChatAttemptState(conversationId, turnId));
     for (const action of resolvedRecords) {
-      if (action.resolvedEvent?.type !== "approval_response" || action.resolvedEvent.approved) continue;
-      rejectedToolCallIds.add(
-        action.kind === "custom_approval" ? (customApprovalParentCallId(action.callId) ?? action.callId) : action.callId,
-      );
+      if (action.resolvedEvent?.type !== "approval_response") continue;
+      // A decision on a custom approval belongs to the call that asked for it.
+      const callId = action.kind === "custom_approval" ? (customApprovalParentCallId(action.callId) ?? action.callId) : action.callId;
+      (action.resolvedEvent.approved ? approvedToolCallIds : rejectedToolCallIds).add(callId);
     }
     pipeline.setRejectedCallIds(rejectedToolCallIds);
+    pipeline.setApprovedCallIds(approvedToolCallIds);
     const assistantMessages = loopMessages.filter((message) => message.message.role !== "user");
     const isFresh = assistantMessages.length === 0 && resolvedRecords.length === 0 && !skipResolvedActions;
 
@@ -1064,8 +1076,19 @@ export class AiTurnExecutor {
     });
     const priorToolRounds = toolRoundState(loopMessages);
     const quotaSubject = accessSubjectForActor(material.actor);
+    const deadline = claim.turn.deadline ? Date.parse(claim.turn.deadline) : null;
     const toolRoundPolicy = applyToolRoundPolicy({
-      provider: assistantQuotaProvider(resolved.provider, config, quotaSubject, resolved.profile, turnId, conversationId),
+      provider: retryTransientProviderErrors(
+        assistantQuotaProvider(resolved.provider, config, quotaSubject, resolved.profile, turnId, conversationId),
+        {
+          deadline,
+          delaysMs: this.config.providerRetryDelaysMs,
+          onRetry: async ({ retry, delayMs, issue }) => {
+            log.warn("AI provider call retried", { conversationId, turnId, retry, delayMs, kind: issue.kind, message: issue.message });
+            await pipeline.emitProviderRetry();
+          },
+        },
+      ),
       tools,
       maxToolRounds: resolved.profile.maxToolRounds,
       issuedToolRounds: priorToolRounds.issued,
@@ -1667,6 +1690,10 @@ class StreamPipeline {
     this.mapper.setRejectedCallIds(callIds);
   }
 
+  setApprovedCallIds(callIds: Set<string>): void {
+    this.mapper.setApprovedCallIds(callIds);
+  }
+
   async emitBaseline(): Promise<void> {
     for (const block of this.blocks) {
       const seq = this.nextSeq();
@@ -1765,6 +1792,12 @@ class StreamPipeline {
     await this.publish(event);
   }
 
+  /** Transient: says a model call is waiting to be retried. Snapshots never carry it. */
+  async emitProviderRetry(): Promise<void> {
+    const seq = this.nextSeq();
+    await this.publish(this.envelope({ type: "provider_retry" as const, seq }));
+  }
+
   async emitTurnFinished(status: "completed" | "failed" | "aborted", error: string | null): Promise<void> {
     const seq = this.nextSeq();
     await this.publish(this.envelope({ type: "turn_finished" as const, seq, status, error }) as AiWireEvent);

package/src/ai/memory-learning.ts

@@ -16,6 +16,7 @@ import {
   listAiTurnWorkflowEvidence,
   markAiWorkflowPatternReviewed,
 } from "./memory-workflow-evidence";
+import { AI_MEMORY_LEARNING_DEFAULT_ENABLED, aiUserPrefs } from "./prefs";
 import { aiConversations } from "./store";
 import type { RunAiStructuredInput, RunAiStructuredResult } from "./structured";
 import { resolveAiBackgroundModel, runAiStructured } from "./structured";
@@ -148,11 +149,11 @@ export const listAiMemoryLearningCandidates = async (limit: number, monthlyToken
         ) AS user_rank
       FROM ai.turns turn
       JOIN ai.conversations conversation ON conversation.id = turn.conversation_id
-      JOIN ai.user_prefs prefs ON prefs.user_id = conversation.created_by_user_id
+      LEFT JOIN ai.user_prefs prefs ON prefs.user_id = conversation.created_by_user_id
       LEFT JOIN monthly_usage usage ON usage.user_id = conversation.created_by_user_id
       WHERE conversation.created_by_user_id IS NOT NULL
         AND conversation.archived_at IS NULL
-        AND prefs.memory_learning_enabled = TRUE
+        AND COALESCE(prefs.memory_learning_enabled, ${AI_MEMORY_LEARNING_DEFAULT_ENABLED})
         AND turn.status = 'completed'
         AND COALESCE(turn.run_config->>'kind', 'chat') = 'chat'
         AND turn.memory_learned_at IS NULL
@@ -196,14 +197,7 @@ const markFailed = async (candidate: Candidate): Promise<void> => {
   `;
 };
 
-const learningEnabled = async (userId: string): Promise<boolean> => {
-  const [row] = await sql<{ enabled: boolean }[]>`
-    SELECT COALESCE(memory_learning_enabled, FALSE) AS enabled
-    FROM ai.user_prefs
-    WHERE user_id = ${userId}::uuid
-  `;
-  return Boolean(row?.enabled);
-};
+const learningEnabled = async (userId: string): Promise<boolean> => (await aiUserPrefs.get(userId)).memoryLearningEnabled;
 
 const monthlyAccountedTokens = async (userId: string): Promise<number> => {
   const [row] = await sql<{ tokens: number }[]>`
@@ -447,7 +441,6 @@ export const learnAiMemoriesFromPrivateChats = async (
     let runId: string | null = null;
     let changes: AiMemoryLearningChange[] = [];
     try {
-      if (!(await learningEnabled(candidate.userId))) continue;
       const evidence = await loadTurnEvidence(candidate);
       if (!evidence.userText) {
         await markLearned(candidate);
@@ -465,6 +458,8 @@ export const learnAiMemoriesFromPrivateChats = async (
       });
       const reservedTokens = estimatedTokens(systemPrompt, taskInput);
       if ((await readMonthlyUsage(candidate.userId)) + reservedTokens > monthlyTokenBudget) continue;
+      // Read the choice again right before the turn can reach the model.
+      if (!(await learningEnabled(candidate.userId))) continue;
       runId = await aiMemoryLearningRuns.start({
         userId: candidate.userId,
         conversationId: candidate.conversationId,
@@ -550,7 +545,6 @@ export const learnAiMemoriesFromPrivateChats = async (
     let runId: string | null = null;
     const startedAt = Date.now();
     try {
-      if (!(await learningEnabled(pattern.userId))) continue;
       const context = await workflowPatternInput(pattern);
       if (!context.source) {
         await markAiWorkflowPatternReviewed(pattern);
@@ -564,6 +558,7 @@ export const learnAiMemoriesFromPrivateChats = async (
       });
       const reservedTokens = estimatedTokens(workflowPrompt, context.input);
       if ((await readMonthlyUsage(pattern.userId)) + reservedTokens > monthlyTokenBudget) continue;
+      if (!(await learningEnabled(pattern.userId))) continue;
       runId = await aiMemoryLearningRuns.start({
         userId: pattern.userId,
         conversationId: context.source.candidate.conversationId,

package/src/ai/memory-workflow-evidence.ts

@@ -1,5 +1,6 @@
 import { sql } from "bun";
 import { type CloudResourceRef, CloudResourceRefSchema } from "../contracts/capabilities";
+import { AI_MEMORY_LEARNING_DEFAULT_ENABLED } from "./prefs";
 
 const MAX_RECEIPT_RESOURCES = 20;
 const MAX_CAPABILITY_ID_CHARS = 180;
@@ -22,7 +23,11 @@ export type AiMemoryWorkflowPattern = {
   turnIds: string[];
 };
 
-/** Persist only successful, schema-valid capability/resource receipts. */
+/**
+ * Persist only successful, schema-valid capability/resource receipts, and only
+ * while learning is on for the user: receipts from a time it was off never
+ * count toward a workflow pattern.
+ */
 export const recordAiMemoryWorkflowEvidence = async (input: {
   userId: string;
   conversationId: string;
@@ -61,9 +66,11 @@ export const recordAiMemoryWorkflowEvidence = async (input: {
           ${resource.ref.type}, ${resource.ref.id}, ${resource.title ?? null}
         FROM ai.turns turn
         JOIN ai.conversations conversation ON conversation.id = turn.conversation_id
+        LEFT JOIN ai.user_prefs prefs ON prefs.user_id = conversation.created_by_user_id
         WHERE turn.id = ${input.turnId}::uuid
           AND conversation.id = ${input.conversationId}::uuid
           AND conversation.created_by_user_id = ${input.userId}::uuid
+          AND COALESCE(prefs.memory_learning_enabled, ${AI_MEMORY_LEARNING_DEFAULT_ENABLED})
         ON CONFLICT (turn_id, capability_id, resource_type, resource_id)
         DO UPDATE SET resource_title = COALESCE(EXCLUDED.resource_title, ai.memory_workflow_evidence.resource_title)
       `;
@@ -116,10 +123,11 @@ export const listAiPendingWorkflowPatterns = async (limit = 5): Promise<AiMemory
              FILTER (WHERE evidence.resource_title IS NOT NULL))[1] AS resource_title,
            count(*)::int AS observation_count
     FROM ai.memory_workflow_evidence evidence
-    JOIN ai.user_prefs prefs ON prefs.user_id = evidence.user_id AND prefs.memory_learning_enabled = TRUE
+    LEFT JOIN ai.user_prefs prefs ON prefs.user_id = evidence.user_id
     JOIN ai.conversations conversation
       ON conversation.id = evidence.conversation_id AND conversation.created_by_user_id = evidence.user_id
     WHERE evidence.reviewed_at IS NULL
+      AND COALESCE(prefs.memory_learning_enabled, ${AI_MEMORY_LEARNING_DEFAULT_ENABLED})
     GROUP BY evidence.user_id, evidence.capability_id, evidence.resource_type, evidence.resource_id
     HAVING count(*) >= 3
     ORDER BY min(evidence.observed_at), evidence.user_id, evidence.capability_id, evidence.resource_type, evidence.resource_id

package/src/ai/migrate.ts

@@ -951,7 +951,7 @@ export const migrateCloudAi = async (): Promise<void> => {
     CREATE TABLE IF NOT EXISTS ai.user_prefs (
       user_id UUID PRIMARY KEY REFERENCES auth.users(id) ON DELETE CASCADE,
       memory_enabled BOOLEAN NOT NULL DEFAULT TRUE,
-      memory_learning_enabled BOOLEAN NOT NULL DEFAULT FALSE,
+      memory_learning_enabled BOOLEAN,
       updated_at TIMESTAMPTZ NOT NULL DEFAULT now()
     )
   `.simple();
@@ -960,7 +960,16 @@ export const migrateCloudAi = async (): Promise<void> => {
   // memory blob. Deliberately discard it instead of migrating ambiguous lines.
   await sql`ALTER TABLE ai.user_prefs DROP COLUMN IF EXISTS memory`.simple();
   await sql`ALTER TABLE ai.user_prefs DROP COLUMN IF EXISTS instructions`.simple();
-  await sql`ALTER TABLE ai.user_prefs ADD COLUMN IF NOT EXISTS memory_learning_enabled BOOLEAN NOT NULL DEFAULT FALSE`.simple();
+  await sql`ALTER TABLE ai.user_prefs ADD COLUMN IF NOT EXISTS memory_learning_enabled BOOLEAN`.simple();
+  // NULL means the user never chose, so the default (on) applies. Earlier
+  // releases stored FALSE for every new row, and an explicit "off" looks the
+  // same, so existing FALSE rows stay as they are rather than being switched on.
+  // memory_learning_chosen_at, added below, tells later explicit choices apart.
+  await sql`
+    ALTER TABLE ai.user_prefs
+      ALTER COLUMN memory_learning_enabled DROP NOT NULL,
+      ALTER COLUMN memory_learning_enabled DROP DEFAULT
+  `.simple();
 
   // Last model the user actually ran a turn with — preselected for new chats.
   await sql`ALTER TABLE ai.user_prefs ADD COLUMN IF NOT EXISTS last_model_id TEXT NOT NULL DEFAULT ''`.simple();
@@ -1125,6 +1134,40 @@ export const migrateCloudAi = async (): Promise<void> => {
     WHERE reviewed_at IS NULL
   `.simple();
 
+  // Learning considers only turns that finish while it is on: completeTurn marks
+  // the others, and receipts are recorded only while it is on. When learning
+  // became the default, every earlier turn and receipt of a person without an
+  // explicit "on" came from a time it was off, so they are marked as considered
+  // exactly once, when the column that records explicit choices is introduced.
+  await sql`
+    DO $$
+    BEGIN
+      IF NOT EXISTS (
+        SELECT 1 FROM information_schema.columns
+        WHERE table_schema = 'ai' AND table_name = 'user_prefs' AND column_name = 'memory_learning_chosen_at'
+      ) THEN
+        ALTER TABLE ai.user_prefs ADD COLUMN memory_learning_chosen_at TIMESTAMPTZ;
+        UPDATE ai.turns turn
+        SET memory_learned_at = COALESCE(turn.completed_at, turn.created_at)
+        FROM ai.conversations conversation
+        WHERE conversation.id = turn.conversation_id
+          AND turn.status = 'completed'
+          AND turn.memory_learned_at IS NULL
+          AND NOT EXISTS (
+            SELECT 1 FROM ai.user_prefs prefs
+            WHERE prefs.user_id = conversation.created_by_user_id AND prefs.memory_learning_enabled
+          );
+        UPDATE ai.memory_workflow_evidence evidence
+        SET reviewed_at = now()
+        WHERE evidence.reviewed_at IS NULL
+          AND NOT EXISTS (
+            SELECT 1 FROM ai.user_prefs prefs
+            WHERE prefs.user_id = evidence.user_id AND prefs.memory_learning_enabled
+          );
+      END IF;
+    END $$
+  `.simple();
+
   await sql`
     CREATE TABLE IF NOT EXISTS ai.memory_learning_runs (
       id UUID PRIMARY KEY DEFAULT gen_random_uuid(),

package/src/ai/model-access.ts

@@ -114,13 +114,14 @@ export const aiModelAccess = {
         service_account_id: string | null;
         authenticated_only: boolean | null;
         display_name: string | null;
+        avatar_hash: string | null;
         service_account_kind: ServiceAccountKind | null;
       }[]
     >`
       SELECT resource.profile_id, resource.revision, access.id, access.created_at,
         access.user_id, access.group_id, access.service_account_id, access.authenticated_only,
-        COALESCE(users.display_name, groups.name, service_accounts.name) AS display_name,
-        service_accounts.kind AS service_account_kind
+        COALESCE(NULLIF(users.display_name, ''), users.uid, groups.name, service_accounts.name) AS display_name,
+        users.avatar_hash, service_accounts.kind AS service_account_kind
       FROM ai.model_access_resources resource LEFT JOIN ai.model_access model ON model.profile_id = resource.profile_id
       LEFT JOIN auth.access access ON access.id = model.access_id
       LEFT JOIN auth.users users ON users.id = access.user_id
@@ -148,6 +149,7 @@ export const aiModelAccess = {
         permission: "read",
         createdAt: row.created_at.toISOString(),
         ...(row.display_name ? { displayName: row.display_name } : {}),
+        ...(row.user_id ? { avatarHash: row.avatar_hash } : {}),
         ...(row.service_account_kind ? { serviceAccountKind: row.service_account_kind } : {}),
       });
     }

package/src/ai/prefs.ts

@@ -1,9 +1,16 @@
 import { sql } from "bun";
 import type { RequestActor } from "../server";
 
+/**
+ * Learning from private chats applies to everyone who has not chosen.
+ * A stored `NULL` means "never chose"; only an explicit save stores a boolean.
+ */
+export const AI_MEMORY_LEARNING_DEFAULT_ENABLED = true;
+
 export type AiUserPrefs = {
   userId: string;
   memoryEnabled: boolean;
+  /** Effective setting: the user's explicit choice, otherwise the default. */
   memoryLearningEnabled: boolean;
   /** Model profile id of the user's most recent chat turn — preselected for new chats. */
   lastModelId: string;
@@ -13,7 +20,7 @@ export type AiUserPrefs = {
 type PrefsRow = {
   user_id: string;
   memory_enabled: boolean;
-  memory_learning_enabled: boolean;
+  memory_learning_enabled: boolean | null;
   last_model_id: string | null;
   updated_at: string | Date;
 };
@@ -21,7 +28,7 @@ type PrefsRow = {
 const toPrefs = (row: PrefsRow): AiUserPrefs => ({
   userId: row.user_id,
   memoryEnabled: row.memory_enabled,
-  memoryLearningEnabled: row.memory_learning_enabled,
+  memoryLearningEnabled: row.memory_learning_enabled ?? AI_MEMORY_LEARNING_DEFAULT_ENABLED,
   lastModelId: row.last_model_id ?? "",
   updatedAt: new Date(row.updated_at).toISOString(),
 });
@@ -29,7 +36,7 @@ const toPrefs = (row: PrefsRow): AiUserPrefs => ({
 const emptyPrefs = (userId: string): AiUserPrefs => ({
   userId,
   memoryEnabled: true,
-  memoryLearningEnabled: false,
+  memoryLearningEnabled: AI_MEMORY_LEARNING_DEFAULT_ENABLED,
   lastModelId: "",
   updatedAt: new Date(0).toISOString(),
 });
@@ -56,13 +63,20 @@ export const aiUserPrefs = {
   ): Promise<AiUserPrefs> {
     const memoryEnabled = patch.memoryEnabled ?? null;
     const memoryLearningEnabled = patch.memoryLearningEnabled ?? null;
+    // Records when the person last saved the learning switch, so a stored "off"
+    // from an earlier release stays distinguishable from a choice made since.
+    const learningChosen = memoryLearningEnabled !== null;
     const lastModelId = patch.lastModelId?.trim().slice(0, 200) ?? null;
     const rows = (await sql`
-      INSERT INTO ai.user_prefs (user_id, memory_enabled, memory_learning_enabled, last_model_id, updated_at)
-      VALUES (${userId}, ${memoryEnabled ?? true}, ${memoryLearningEnabled ?? false}, ${lastModelId ?? ""}, now())
+      INSERT INTO ai.user_prefs (user_id, memory_enabled, memory_learning_enabled, memory_learning_chosen_at, last_model_id, updated_at)
+      VALUES (
+        ${userId}, ${memoryEnabled ?? true}, ${memoryLearningEnabled},
+        CASE WHEN ${learningChosen}::boolean THEN now() END, ${lastModelId ?? ""}, now()
+      )
       ON CONFLICT (user_id) DO UPDATE SET
         memory_enabled = COALESCE(${memoryEnabled}, ai.user_prefs.memory_enabled),
         memory_learning_enabled = COALESCE(${memoryLearningEnabled}, ai.user_prefs.memory_learning_enabled),
+        memory_learning_chosen_at = CASE WHEN ${learningChosen}::boolean THEN now() ELSE ai.user_prefs.memory_learning_chosen_at END,
         last_model_id = COALESCE(${lastModelId}, ai.user_prefs.last_model_id),
         updated_at = now()
       RETURNING *

package/src/ai/projects.ts

@@ -82,6 +82,7 @@ export type AiProjectAccess = {
   principal: Principal;
   permission: AiProjectPermission;
   displayName?: string;
+  avatarHash?: string | null;
   /** Kind of a `service_account` principal; presentation only. */
   serviceAccountKind?: ServiceAccountKind;
   createdAt: string;
@@ -157,6 +158,7 @@ type ProjectAccessRow = {
   permission: AiProjectPermission;
   created_at: Date | string;
   display_name: string | null;
+  avatar_hash: string | null;
   service_account_kind: ServiceAccountKind | null;
 };
 
@@ -260,6 +262,7 @@ const toProjectAccess = (row: ProjectAccessRow): AiProjectAccess => ({
           : { type: "public" },
   permission: row.permission,
   displayName: row.display_name ?? undefined,
+  ...(row.user_id ? { avatarHash: row.avatar_hash } : {}),
   serviceAccountKind: row.service_account_kind ?? undefined,
   createdAt: iso(row.created_at),
 });
@@ -290,9 +293,9 @@ const listProjectAccess = async (projectId: string, db: SQL = sql): Promise<AiPr
   const rows = await db<ProjectAccessRow[]>`
     SELECT project_access.short_id, access.user_id, access.group_id, access.service_account_id, access.authenticated_only,
            access.permission, access.created_at,
-           COALESCE(users.display_name, groups.name, service_accounts.name,
+           COALESCE(NULLIF(users.display_name, ''), users.uid, groups.name, service_accounts.name,
              CASE WHEN access.authenticated_only THEN 'All authenticated users' ELSE 'Public' END) AS display_name,
-           service_accounts.kind AS service_account_kind
+           users.avatar_hash, service_accounts.kind AS service_account_kind
     FROM ai.project_access project_access
     JOIN auth.access access ON access.id = project_access.access_id
     LEFT JOIN auth.users users ON users.id = access.user_id

package/src/ai/protocol.ts

@@ -39,6 +39,8 @@ export type AiTurnBlock =
       isError?: boolean;
       /** Present while status is awaiting_approval. */
       approval?: { message?: string; review?: CapabilityActionReview; allowAlways: boolean };
+      /** The user approved this call in the chat; the decided approval stays visible as a receipt. */
+      approved?: boolean;
       /** Present for frontend tools. */
       frontendMode?: AiFrontendToolMode;
       /** Saved Cloud-owned display snapshot for capability calls. */
@@ -67,6 +69,8 @@ export type AiWireEvent =
   | (AiWireEventBase & { type: "message_saved"; message: AiStoredMessage })
   | (AiWireEventBase & { type: "block_set"; block: AiTurnBlock })
   | (AiWireEventBase & { type: "block_delta"; blockId: string; blockKind: "text" | "thinking"; delta: string })
+  /** A model call failed transiently and waits for its retry. Transient: the next event of the turn ends it. */
+  | (AiWireEventBase & { type: "provider_retry" })
   | (AiWireEventBase & {
       type: "turn_finished";
       status: AiTurnFinishedStatus;
@@ -85,6 +89,10 @@ export type AiTurnSnapshot = {
   blocks: AiTurnBlock[];
   modelProfileId: string | null;
   createdAt: string;
+  /** Time the turn already waited for answered user actions such as approvals. Absent from older servers. */
+  actionWaitMs?: number;
+  /** Start of the user action the turn waits for now, or null while it works. Absent from older servers. */
+  waitingSince?: string | null;
 };
 
 /** Full projection seed sent as the first SSE event on every (re)connect. */
@@ -151,7 +159,12 @@ export const reconcileResolvedTurnActions = (
     const event = resolvedByCallId.get(block.callId);
     if (!event || event.callId !== block.callId) return block;
     if (block.status === "awaiting_approval" && event.type === "approval_response") {
-      return { ...block, status: event.approved ? "running" : "rejected", approval: undefined };
+      return {
+        ...block,
+        status: event.approved ? "running" : "rejected",
+        approval: undefined,
+        ...(event.approved ? { approved: true } : {}),
+      };
     }
     if (block.status === "awaiting_client" && event.type === "tool_result") {
       return { ...block, status: "completed", result: event.result, isError: false };
@@ -172,7 +185,7 @@ export const buildBlocksFromMessages = (
     meta?: {
       steerId?: string;
       toolPresentations?: Record<string, AiToolPresentation>;
-      toolOutcomes?: Record<string, "rejected">;
+      toolOutcomes?: Record<string, "rejected" | "approved">;
     } | null;
   }[],
 ): AiTurnBlock[] => {
@@ -196,6 +209,8 @@ export const buildBlocksFromMessages = (
             args: block.args,
             status: "running",
             presentation: meta?.toolPresentations?.[block.id],
+            // A turn that ended before an approved call returned records the approval on the call's message.
+            ...(meta?.toolOutcomes?.[block.id] === "approved" ? { approved: true } : {}),
           });
         }
       });
@@ -212,12 +227,13 @@ export const buildBlocksFromMessages = (
       const at = toolIndex.get(message.callId);
       const existing = at !== undefined ? blocks[at] : undefined;
       if (existing?.kind === "tool") {
-        const rejected = meta?.toolOutcomes?.[message.callId] === "rejected";
+        const outcome = meta?.toolOutcomes?.[message.callId];
         blocks[at!] = {
           ...existing,
-          status: rejected ? "rejected" : message.isError ? "failed" : "completed",
+          status: outcome === "rejected" ? "rejected" : message.isError ? "failed" : "completed",
           result: message.result,
           isError: message.isError,
+          ...(outcome === "approved" ? { approved: true } : {}),
         };
       }
     }