@k2b/cloud 0.24.0 → 0.26.0

package/src/ai/provider-fetch.ts

@@ -1,27 +1,63 @@
 import { AsyncLocalStorage } from "node:async_hooks";
 
 /**
- * Dates the provider response headers and the first body byte of the inference
- * call that is currently streaming, without touching the wire. nessi adapters
- * call the global `fetch`; the wrapper is installed once, on first use, and
- * only observes requests made inside `runWithProviderFetchMarks`.
+ * Observes the provider request of the inference call that is currently
+ * running, without touching the wire: when its headers and first body byte
+ * arrived, whether the provider certainly did not process it, and how long a
+ * rejecting provider asked the caller to wait. nessi adapters call the global
+ * `fetch`; the wrapper is installed once, on first use, and only observes
+ * requests made inside `runWithProviderFetchMarks`. Scopes nest, so an outer
+ * retry policy and the inner per-call accounting each see the same request.
  *
  * Nothing here logs: frames may carry reasoning text and headers carry keys.
  */
-export type ProviderFetchMarks = { headersAt?: number; firstByteAt?: number };
+export type ProviderFetchMarks = {
+  headersAt?: number;
+  firstByteAt?: number;
+  /** The request never reached the provider, or the provider answered with a status that says it did not process it. */
+  refused?: boolean;
+  retryAfterMs?: number;
+};
 
-const marks = new AsyncLocalStorage<ProviderFetchMarks>();
+const scopes = new AsyncLocalStorage<readonly ProviderFetchMarks[]>();
 let installed = false;
 
 export const runWithProviderFetchMarks = <T>(store: ProviderFetchMarks, run: () => Promise<T>): Promise<T> => {
   install();
-  return marks.run(store, run);
+  return scopes.run([...(scopes.getStore() ?? []), store], run);
+};
+
+/** `retry-after-ms` (OpenAI) wins over the standard `retry-after` seconds or HTTP date. */
+export const retryAfterMs = (headers: Headers, now = Date.now()): number | undefined => {
+  const milliseconds = Number(headers.get("retry-after-ms")?.trim() || Number.NaN);
+  if (Number.isFinite(milliseconds) && milliseconds >= 0) return milliseconds;
+  const value = headers.get("retry-after")?.trim();
+  if (!value) return undefined;
+  const seconds = Number(value);
+  if (Number.isFinite(seconds)) return seconds >= 0 ? seconds * 1_000 : undefined;
+  const date = Date.parse(value);
+  return Number.isFinite(date) ? Math.max(0, date - now) : undefined;
 };
 
-const firstByteObserver = (store: ProviderFetchMarks) =>
+/**
+ * A client error, 503, or Anthropic's overloaded 529 says the provider did not
+ * process the request. Other server errors, such as a gateway's 502 or 504, can
+ * follow processing upstream.
+ */
+const refusedStatus = (status: number) => (status >= 400 && status < 500) || status === 503 || status === 529;
+
+/** Bun's codes for a request that never left: no connection, or no address for the host. */
+const unsentCodes = new Set(["ConnectionRefused", "ENOTFOUND"]);
+const unsent = (error: unknown) =>
+  typeof error === "object" && error !== null && "code" in error && typeof error.code === "string" && unsentCodes.has(error.code);
+
+const firstByteObserver = (stores: readonly ProviderFetchMarks[]) =>
   new TransformStream<Uint8Array, Uint8Array>({
     transform(chunk, controller) {
-      if (chunk.byteLength > 0 && store.firstByteAt === undefined) store.firstByteAt = Date.now();
+      if (chunk.byteLength > 0)
+        for (const store of stores) {
+          store.firstByteAt ??= Date.now();
+        }
       controller.enqueue(chunk);
     },
   });
@@ -31,13 +67,29 @@ const install = (): void => {
   installed = true;
   const realFetch = globalThis.fetch;
   const instrumented = async (input: RequestInfo | URL, init?: RequestInit): Promise<Response> => {
-    const store = marks.getStore();
-    // Only the first request of a call is the provider request; nessi retries create a new call.
-    if (store === undefined || store.headersAt !== undefined) return realFetch(input, init);
-    const response = await realFetch(input, init);
-    store.headersAt = Date.now();
+    // Only the first request of a scope is its provider request; a retry opens a new scope.
+    const stores = (scopes.getStore() ?? []).filter((store) => store.headersAt === undefined);
+    if (stores.length === 0) return realFetch(input, init);
+    let response: Response;
+    try {
+      response = await realFetch(input, init);
+    } catch (error) {
+      // A reset, an abort, or a timeout can follow delivery, so only an unsent request counts as refused.
+      if (unsent(error))
+        for (const store of stores) {
+          store.refused = true;
+        }
+      throw error;
+    }
+    const headersAt = Date.now();
+    const wait = response.ok ? undefined : retryAfterMs(response.headers, headersAt);
+    for (const store of stores) {
+      store.headersAt = headersAt;
+      store.refused = refusedStatus(response.status);
+      if (wait !== undefined) store.retryAfterMs = wait;
+    }
     if (!response.body) return response;
-    return new Response(response.body.pipeThrough(firstByteObserver(store)), {
+    return new Response(response.body.pipeThrough(firstByteObserver(stores)), {
       status: response.status,
       statusText: response.statusText,
       headers: response.headers,

package/src/ai/provider-retry.ts

@@ -0,0 +1,105 @@
+import { setTimeout as delay } from "node:timers/promises";
+import type { NessiIssue, Provider, ProviderIssue, StreamEvent, TimeoutIssue } from "@k2b/nessi/ai";
+import { type ProviderFetchMarks, runWithProviderFetchMarks } from "./provider-fetch";
+
+/** Waits before the first and the second retry when the provider names none. nessi itself never retries. */
+export const AI_PROVIDER_RETRY_DELAYS_MS: readonly number[] = [1_000, 4_000];
+
+/**
+ * The longest Retry-After that is honored, the bound the OpenAI and Anthropic
+ * SDKs apply. A provider that asks for a longer wait is unavailable for this
+ * turn, so the call fails now with the provider's message.
+ */
+const AI_PROVIDER_MAX_RETRY_AFTER_MS = 60_000;
+
+export type AiProviderRetry = {
+  /** 1 for the first retry. */
+  retry: number;
+  delayMs: number;
+  issue: ProviderIssue | TimeoutIssue;
+};
+
+const transientIssue = (issue: NessiIssue): issue is ProviderIssue | TimeoutIssue =>
+  (issue.kind === "provider_error" && issue.retryable && !issue.contextOverflow) ||
+  (issue.kind === "timeout" && issue.retryable && issue.scope !== "tool");
+
+const isBlockEvent = (event: StreamEvent) => event.type === "block_start" || event.type === "block_delta" || event.type === "block_end";
+
+/**
+ * Repeats a model call that failed transiently (429, 5xx, a lost connection, a
+ * provider timeout) before it produced any output. Each attempt passes through
+ * `provider` again, so quota admission and accounting see every request.
+ *
+ * Once a block event was emitted the attempt is final: streamed text cannot be
+ * taken back, so a failure mid-stream still ends the call. Context overflow is
+ * left to compaction. Waits follow the provider's Retry-After, otherwise
+ * `delaysMs`, end before `deadline`, and stop on the request's abort signal.
+ */
+export function retryTransientProviderErrors(
+  provider: Provider,
+  options: {
+    /** Epoch milliseconds by which a wait must end; null when the turn has no run time limit. */
+    deadline: number | null;
+    delaysMs?: readonly number[];
+    /** Announces a wait before it starts. */
+    onRetry?: (retry: AiProviderRetry) => Promise<void>;
+  },
+): Provider {
+  const delays = options.delaysMs ?? AI_PROVIDER_RETRY_DELAYS_MS;
+  const waitFor = (retry: number, marks: ProviderFetchMarks, signal: AbortSignal | undefined): number | null => {
+    if (retry >= delays.length || signal?.aborted) return null;
+    const delayMs = marks.retryAfterMs ?? delays[retry]!;
+    if (delayMs > AI_PROVIDER_MAX_RETRY_AFTER_MS) return null;
+    if (options.deadline !== null && Date.now() + delayMs >= options.deadline) return null;
+    return delayMs;
+  };
+  return {
+    name: provider.name,
+    family: provider.family,
+    model: provider.model,
+    contextWindow: provider.contextWindow,
+    capabilities: provider.capabilities,
+    complete: (request) => provider.complete(request),
+    stream: async function* (request) {
+      for (let retry = 0; ; retry += 1) {
+        const marks: ProviderFetchMarks = {};
+        const events = provider.stream(request)[Symbol.asyncIterator]();
+        const next = () => runWithProviderFetchMarks(marks, () => events.next());
+        // Events before the first block (usage, issues) are held so that a retried attempt leaves no trace.
+        const held: StreamEvent[] = [];
+        let committed = false;
+        let pending: AiProviderRetry | null = null;
+        try {
+          for (let step = await next(); !step.done; step = await next()) {
+            const event = step.value;
+            if (!committed && event.type === "issue" && transientIssue(event.issue)) {
+              const delayMs = waitFor(retry, marks, request.signal);
+              if (delayMs !== null) {
+                pending = { retry: retry + 1, delayMs, issue: event.issue };
+                break;
+              }
+            }
+            if (!committed && !isBlockEvent(event)) {
+              held.push(event);
+              continue;
+            }
+            if (!committed) {
+              committed = true;
+              yield* held.splice(0);
+            }
+            yield event;
+          }
+        } finally {
+          // Settles the failed attempt's accounting before the wait starts.
+          await events.return?.();
+        }
+        if (!pending) {
+          yield* held;
+          return;
+        }
+        await options.onRetry?.(pending);
+        await delay(pending.delayMs, undefined, { signal: request.signal });
+      }
+    },
+  };
+}

package/src/ai/quota-provider.ts

@@ -5,7 +5,7 @@ import type { AccessSubject } from "../server/services/access";
 import { logger } from "../services/logging";
 import { isAssistantChatTurn } from "./assistant-models";
 import { AiBackgroundAdmissionError, type AiCallContext, type AiCallDetails, beginAiCall, finishAiCall } from "./inference-calls";
-import { runWithProviderFetchMarks } from "./provider-fetch";
+import { type ProviderFetchMarks, runWithProviderFetchMarks } from "./provider-fetch";
 import type { AiModelProfile } from "./types";
 
 const log = logger("ai:quotas");
@@ -93,7 +93,7 @@ export function inferenceProvider(
       let status: "ok" | "failed" = "failed";
       let error: string | undefined;
       const requestStartedAt = Date.now();
-      const marks: { headersAt?: number; firstByteAt?: number } = {};
+      const marks: ProviderFetchMarks = {};
       try {
         const result = await runWithProviderFetchMarks(marks, () =>
           provider.complete({ ...request, maxOutputTokens: call.maxOutputTokens }),
@@ -112,7 +112,9 @@ export function inferenceProvider(
         throw thrown;
       } finally {
         call.stop();
-        if (!usage && status === "failed") usage = { input: call.inputTokens, output: 0, estimated: true };
+        // A request the provider refused or never received cost nothing; any other failure may have been processed.
+        if (!usage && status === "failed")
+          usage = marks.refused ? { input: 0, output: 0 } : { input: call.inputTokens, output: 0, estimated: true };
         const cancelled = request.signal?.aborted === true;
         await finish(call.id, usage, cancelled && status === "failed" ? "aborted" : status, {
           error: cancelled ? null : error,
@@ -133,7 +135,7 @@ export function inferenceProvider(
       const outputBlocks = new Map<string, number>();
       let generated = false;
       const requestStartedAt = Date.now();
-      const marks: { headersAt?: number; firstByteAt?: number; firstBlockAt?: number } = {};
+      const marks: ProviderFetchMarks & { firstBlockAt?: number } = {};
       // The wrapped adapter reads lazily, so the request only leaves once the first pull runs inside the marked scope.
       const events = provider.stream({ ...request, maxOutputTokens: call.maxOutputTokens })[Symbol.asyncIterator]();
       const next = () => runWithProviderFetchMarks(marks, () => events.next());
@@ -158,7 +160,14 @@ export function inferenceProvider(
             outputBlocks.set(event.blockId, size);
           }
           if (event.type === "block_start" || event.type === "block_delta" || event.type === "block_end") generated = true;
-          if (event.type === "issue" && event.issue.kind === "provider_error" && event.issue.contextOverflow && !generated && !usage)
+          // A provider that refused the request, or never received it, did not process it.
+          if (
+            event.type === "issue" &&
+            event.issue.kind === "provider_error" &&
+            (event.issue.contextOverflow || marks.refused) &&
+            !generated &&
+            !usage
+          )
             usage = { input: 0, output: 0 };
           if (event.type === "usage") {
             if (event.finishReason === "aborted" || event.finishReason === "interrupted" || event.finishReason === "error") failed = true;

package/src/ai/skills.ts

@@ -58,6 +58,7 @@ export type AiSkillAccess = {
   principal: Principal;
   permission: AiSkillPermission;
   displayName?: string;
+  avatarHash?: string | null;
   /** Kind of a `service_account` principal; presentation only. */
   serviceAccountKind?: ServiceAccountKind;
   createdAt: string;
@@ -130,6 +131,7 @@ type SkillAccessRow = {
   permission: AiSkillPermission;
   created_at: Date | string;
   display_name: string | null;
+  avatar_hash: string | null;
   service_account_kind: ServiceAccountKind | null;
 };
 
@@ -284,9 +286,9 @@ const listSkillAccess = async (skillId: string, db: SQL = sql): Promise<AiSkillA
   const rows = await db<SkillAccessRow[]>`
     SELECT skill_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.skill_access skill_access
     JOIN auth.access access ON access.id = skill_access.access_id
     LEFT JOIN auth.users users ON users.id = access.user_id
@@ -309,6 +311,7 @@ const listSkillAccess = async (skillId: string, db: SQL = sql): Promise<AiSkillA
             : { 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),
   }));

package/src/ai/store.ts

@@ -4,9 +4,11 @@ import { type SQL, sql } from "bun";
 import { type CapabilityActionReview, CapabilityActionReviewSchema } from "../contracts/capabilities";
 import { logger } from "../services/logging";
 import { toPgTextArray } from "../services/postgres";
+import { AI_MEMORY_LEARNING_DEFAULT_ENABLED } from "./prefs";
 import type { AiTurnBlock } from "./protocol";
 import { withAiShortId, withAiShortIdForDb } from "./short-id";
 import { parseAiTodoPlan } from "./todo-contracts";
+import { activeTurnWaits } from "./turn-timing";
 import type {
   AiConversation,
   AiConversationDraft,
@@ -776,6 +778,76 @@ const messageSearchText = (message: Message): string => {
   return text.slice(0, SEARCH_TEXT_MAX_CHARS);
 };
 
+/**
+ * Record how a turn ended on its messages when its loop could not record it: a stop while an approval waits, a run
+ * time limit, or a turn the sweep finalizes. History reads the ending from the last assistant message, so such a turn
+ * never looks finished. A failure replaces the `aborted` that a loop cut off by its run time limit recorded, so the
+ * limit never looks like a user stop. A call the user approved that never returned keeps its approval in history.
+ */
+const recordTurnEnd = async (
+  db: typeof sql,
+  input: { conversationId: string; turnId: string; reason: "aborted" | "error" },
+): Promise<void> => {
+  const replaces = input.reason === "error" ? "aborted" : null;
+  for (const table of ["ai.messages", "ai.task_messages"]) {
+    await db`
+      UPDATE ${db(table)}
+      SET loop_done_reason = ${input.reason}
+      WHERE id = (
+        SELECT id
+        FROM ${db(table)}
+        WHERE conversation_id = ${input.conversationId}
+          AND loop_id = ${input.turnId}::text
+          AND compacted_at IS NULL
+          AND kind = 'message'
+          AND role = 'assistant'
+        ORDER BY seq DESC
+        LIMIT 1
+      )
+        AND (loop_done_reason IS NULL OR loop_done_reason = ${replaces}::text)
+    `;
+    // An approved call without a result keeps the decision on the message that holds the call. A decision on a custom
+    // approval belongs to the call that asked for it.
+    await db`
+      UPDATE ${db(table)} target
+      SET meta = jsonb_set(
+        COALESCE(target.meta, '{}'::jsonb),
+        '{toolOutcomes}',
+        COALESCE(target.meta->'toolOutcomes', '{}'::jsonb) || outcomes.value
+      )
+      FROM (
+        SELECT message.id, jsonb_object_agg(approved.call_id, 'approved'::text) AS value
+        FROM (
+          SELECT DISTINCT
+            CASE
+              WHEN action.kind = 'custom_approval' THEN COALESCE(substring(action.call_id FROM '^(.*)-approval-[0-9]+$'), action.call_id)
+              ELSE action.call_id
+            END AS call_id
+          FROM ai.pending_actions action
+          WHERE action.turn_id = ${input.turnId}
+            AND action.resolved_event->>'type' = 'approval_response'
+            AND action.resolved_event->>'approved' = 'true'
+        ) approved
+        JOIN ${db(table)} message
+          ON message.conversation_id = ${input.conversationId}
+          AND message.loop_id = ${input.turnId}::text
+          AND message.role = 'assistant'
+          AND message.message->'content' @> jsonb_build_array(jsonb_build_object('type', 'tool_call', 'id', approved.call_id))
+        WHERE NOT EXISTS (
+          SELECT 1
+          FROM ${db(table)} result
+          WHERE result.conversation_id = ${input.conversationId}
+            AND result.loop_id = ${input.turnId}::text
+            AND result.role = 'tool_result'
+            AND result.message->>'callId' = approved.call_id
+        )
+        GROUP BY message.id
+      ) outcomes
+      WHERE target.id = outcomes.id
+    `;
+  }
+};
+
 /** Insert a message inside an open conversation-lock transaction and bump the conversation. */
 const insertMessageLocked = async (
   input: {
@@ -924,10 +996,14 @@ const toolMessageMeta = (
   message: Message,
   presentations: ReadonlyMap<string, AiToolPresentation> | undefined,
   rejectedToolCallIds: ReadonlySet<string> | undefined,
+  approvedToolCallIds?: ReadonlySet<string>,
 ): AiStoredMessage["meta"] => {
   if (message.role === "tool_result" && rejectedToolCallIds?.has(message.callId)) {
     return { toolOutcomes: { [message.callId]: "rejected" } };
   }
+  if (message.role === "tool_result" && approvedToolCallIds?.has(message.callId)) {
+    return { toolOutcomes: { [message.callId]: "approved" } };
+  }
   if (message.role !== "assistant" || !presentations || presentations.size === 0) return null;
   const toolPresentations = Object.fromEntries(
     message.content.flatMap((block) => {
@@ -2617,10 +2693,14 @@ export const aiConversations: AiConversationService = {
       LIMIT 1
     `;
     if (!rows[0]) return null;
+    // The waits let a reconnecting client show work time without time spent waiting for the user.
+    const waits = await activeTurnWaits(rows[0].id);
     return {
       turn: rowToTurn(rows[0]),
       liveBlocks: rowToLiveBlocks(rows[0]),
       liveSeq: Number(rows[0].live_seq ?? 0),
+      actionWaitMs: Math.max(0, Math.round(waits.actionWaitMs)),
+      waitingSince: waits.waitingSince,
     };
   },
 
@@ -2801,6 +2881,19 @@ export const aiConversations: AiConversationService = {
             live_blocks = NULL
         WHERE id = ${input.turnId}
       `;
+      if (input.status === "completed") {
+        // Learning considers only turns that finish while it is on for the chat
+        // owner; turning it on later does not reach back to this turn.
+        await tx`
+          UPDATE ai.turns turn
+          SET memory_learned_at = turn.completed_at
+          FROM ai.conversations conversation
+          LEFT JOIN ai.user_prefs prefs ON prefs.user_id = conversation.created_by_user_id
+          WHERE turn.id = ${input.turnId}
+            AND conversation.id = turn.conversation_id
+            AND NOT COALESCE(prefs.memory_learning_enabled, ${AI_MEMORY_LEARNING_DEFAULT_ENABLED})
+        `;
+      }
       await tx`
         UPDATE ai.pending_actions
         SET status = 'aborted', resolved_at = COALESCE(resolved_at, now())
@@ -2808,6 +2901,11 @@ export const aiConversations: AiConversationService = {
           AND status = 'pending'
       `;
       if (input.status !== "completed") {
+        await recordTurnEnd(tx, {
+          conversationId: input.conversationId,
+          turnId: input.turnId,
+          reason: input.status === "aborted" ? "aborted" : "error",
+        });
         await tx`
           UPDATE ai.turn_steers
           SET status = 'discarded', consumed_at = COALESCE(consumed_at, now())
@@ -2908,7 +3006,7 @@ export const aiConversations: AiConversationService = {
     }));
 
     // 3) Finalize aborts: cancel-requested turns without a live lease, and expired waits.
-    const abortedRows = await sql<{ id: string; conversation_id: string; attempt: number; live_seq: number | string }[]>`
+    const abortedRows = await sql<{ id: string; conversation_id: string; attempt: number; live_seq: number | string; stopped: boolean }[]>`
       UPDATE ai.turns
       SET status = 'aborted',
           completed_at = now(),
@@ -2925,7 +3023,7 @@ export const aiConversations: AiConversationService = {
           )
         LIMIT ${limit}
       )
-      RETURNING id, conversation_id, attempt, live_seq
+      RETURNING id, conversation_id, attempt, live_seq, cancel_requested_at IS NOT NULL AS stopped
     `;
     result.aborted = abortedRows.map((row) => ({
       conversationId: row.conversation_id,
@@ -2934,7 +3032,14 @@ export const aiConversations: AiConversationService = {
       seq: Number(row.live_seq) + 1,
     }));
 
+    // History tells a stop from a turn that failed or whose wait expired, as it does for turns that end on their own.
+    const stopped = new Set(abortedRows.filter((row) => row.stopped).map((row) => row.id));
     for (const finalized of [...result.failed, ...result.aborted]) {
+      await recordTurnEnd(sql, {
+        conversationId: finalized.conversationId,
+        turnId: finalized.turnId,
+        reason: stopped.has(finalized.turnId) ? "aborted" : "error",
+      });
       await sql`
         UPDATE ai.pending_actions
         SET status = 'aborted', resolved_at = COALESCE(resolved_at, now())
@@ -3286,7 +3391,7 @@ export const aiConversations: AiConversationService = {
     append: async (message, opts) => {
       // Initial input and durable steering are already persisted transactionally before Nessi appends them.
       if (message.role === "user") return;
-      const meta = toolMessageMeta(message, input.toolPresentations, input.rejectedToolCallIds);
+      const meta = toolMessageMeta(message, input.toolPresentations, input.rejectedToolCallIds, input.approvedToolCallIds);
 
       if (input.turnId && input.leaseOwner) {
         const appended = await appendTurnOwnedMessage({

package/src/ai/stream.ts

@@ -94,6 +94,8 @@ const turnSnapshotFromActive = (active: NonNullable<Awaited<ReturnType<typeof ai
   blocks: [...active.liveBlocks],
   modelProfileId: active.turn.modelProfileId,
   createdAt: active.turn.createdAt,
+  actionWaitMs: active.actionWaitMs,
+  waitingSince: active.waitingSince,
 });
 
 /** Initial history window; older messages load on demand while scrolling up. */

package/src/ai/timeline.ts

@@ -12,9 +12,9 @@ export type AiAssistantTimelineItem = {
   /** The entry whose message-actions row (copy/retry/fork) is shown. */
   actionEntry: AiStoredMessage | null;
   /**
-   * Active work duration of the loop (nessi timing: generation + tool
-   * execution, excluding approval/client waits); legacy fallback is user
-   * message submitted → last message persisted. Retained for response metrics.
+   * Work time of the loop: wall time minus time spent waiting for user actions,
+   * from the loop's durable timing. Without timing, the time from the user
+   * message to the last persisted message.
    */
   workedMs: number;
 };
@@ -32,13 +32,6 @@ export const assistantVisibleTextFromMessage = (message: Message): string => {
     .trim();
 };
 
-export const copyTextFromAssistantEntries = (entries: AiStoredMessage[]): string =>
-  entries
-    .map((entry) => assistantVisibleTextFromMessage(entry.message))
-    .filter(Boolean)
-    .join("\n\n")
-    .trim();
-
 const isAssistantPart = (entry: AiStoredMessage): boolean =>
   entry.kind === "message" && (entry.message.role === "assistant" || entry.message.role === "tool_result");
 
@@ -123,7 +116,12 @@ export const buildAiMessageTimeline = (messages: AiStoredMessage[]): AiMessageTi
     const startedAt =
       loopId && lastUserEntry?.loopId === loopId ? timestampMs(lastUserEntry.createdAt) : timestampMs(entries[0]?.createdAt);
     const finishedAt = timestampMs(entries.at(-1)?.createdAt);
-    const workedMs = startedAt !== null && finishedAt !== null ? Math.max(0, finishedAt - startedAt) : 0;
+    const timing = entries.findLast((stored) => stored.loopAggregate?.timing)?.loopAggregate?.timing;
+    const workedMs = timing
+      ? Math.max(0, timing.wallMs - timing.actionWaitMs)
+      : startedAt !== null && finishedAt !== null
+        ? Math.max(0, finishedAt - startedAt)
+        : 0;
 
     const blocks = [
       ...steerBlocks,

package/src/ai/turn-timing.ts

@@ -80,6 +80,36 @@ export function createTurnTimingRecorder(turnId: string, db = sql) {
   };
 }
 
+/**
+ * Time a turn waited for the person: approvals and answers until they were given. A tool the browser runs by itself
+ * waits only until it starts; a secret prompt waits for its answer even though the browser claimed it. An open wait
+ * ends now.
+ */
+const actionWaits = (turnId: string, db: typeof sql) =>
+  db<{ start: Date; end: Date; open: boolean }[]>`SELECT a.created_at AS start,
+    COALESCE(w.end, now()) AS end, w.end IS NULL AS open
+    FROM ai.pending_actions a LEFT JOIN ai.tool_calls t ON t.turn_id=a.turn_id AND t.call_id=a.call_id
+    CROSS JOIN LATERAL (SELECT CASE WHEN a.kind='client_tool' AND a.tool_name<>'code_secret' THEN LEAST(t.started_at,a.resolved_at)
+      ELSE a.resolved_at END AS end) w
+    WHERE a.turn_id=${turnId}::uuid`;
+
+/**
+ * Waits of a running turn by the same rules as its durable timing: `actionWaitMs` is the time already waited, and
+ * `waitingSince` the start of the wait that is still open, overlapping waits counted once.
+ */
+export async function activeTurnWaits(turnId: string, db = sql): Promise<{ actionWaitMs: number; waitingSince: string | null }> {
+  const rows = await actionWaits(turnId, db);
+  const waits = union(rows.map((x) => ({ start: new Date(x.start).getTime(), end: new Date(x.end).getTime() })));
+  const opens = rows.filter((x) => x.open).map((x) => new Date(x.start).getTime());
+  const openStart = opens.length > 0 ? Math.min(...opens) : null;
+  // An open wait reaches until now, so the merged wait that holds it is the last one.
+  const current = openStart === null ? undefined : waits.find((x) => x.start <= openStart && openStart <= x.end);
+  return {
+    actionWaitMs: duration(waits.filter((x) => x !== current)),
+    waitingSince: current ? new Date(current.start).toISOString() : null,
+  };
+}
+
 export async function withDurableTurnTiming(turnId: string, aggregate: LoopAggregate, db = sql): Promise<LoopAggregate> {
   const [turn] = await db<
     { start: Date; end: Date }[]
@@ -95,9 +125,7 @@ export async function withDurableTurnTiming(turnId: string, aggregate: LoopAggre
   const tools = await db<
     { start: Date; end: Date }[]
   >`SELECT started_at AS start,COALESCE(completed_at,now()) AS end FROM ai.tool_calls WHERE turn_id=${turnId}::uuid AND started_at IS NOT NULL`;
-  const waits = await db<{ start: Date; end: Date }[]>`SELECT a.created_at AS start,
-    CASE WHEN a.kind='client_tool' THEN LEAST(COALESCE(t.started_at,a.resolved_at,now()),COALESCE(a.resolved_at,now())) ELSE COALESCE(a.resolved_at,now()) END AS end
-    FROM ai.pending_actions a LEFT JOIN ai.tool_calls t ON t.turn_id=a.turn_id AND t.call_id=a.call_id WHERE a.turn_id=${turnId}::uuid`;
+  const waits = await actionWaits(turnId, db);
   const intervals = (rows: { start: Date; end: Date | null }[]) =>
     rows.flatMap((x) => (x.end ? [{ start: new Date(x.start).getTime(), end: new Date(x.end).getTime() }] : []));
   return {

package/src/ai/types.ts

@@ -296,7 +296,7 @@ export type AiStoredMessage = {
       trigger: "scheduled" | "manual";
     };
     toolPresentations?: Record<string, AiToolPresentation>;
-    toolOutcomes?: Record<string, "rejected">;
+    toolOutcomes?: Record<string, "rejected" | "approved">;
   } | null;
   /** Private owner feedback for this rendered assistant response. Never enters model context. */
   feedback?: AiMessageFeedback | null;
@@ -864,7 +864,15 @@ export type AiConversationService = {
   getLatestTurn(input: { conversationId: string }): Promise<AiTurn | null>;
   getTurn(input: { conversationId: string; turnId: string }): Promise<AiTurn | null>;
   getTurnByShortId(input: { conversationId: string; shortId: string }): Promise<AiTurn | null>;
-  getActiveTurn(input: { conversationId: string }): Promise<{ turn: AiTurn; liveBlocks: AiTurnBlock[]; liveSeq: number } | null>;
+  getActiveTurn(input: { conversationId: string }): Promise<{
+    turn: AiTurn;
+    liveBlocks: AiTurnBlock[];
+    liveSeq: number;
+    /** Time spent waiting for answered user actions. */
+    actionWaitMs: number;
+    /** Start of the oldest unanswered user action, if the turn waits now. */
+    waitingSince: string | null;
+  } | null>;
   /**
    * Claim a turn attempt. Increments attempt and takes the lease atomically.
    * `from: "queue"` claims queued or lease-expired running turns; `from: "waiting"`
@@ -944,6 +952,8 @@ export type AiConversationService = {
     toolPresentations?: ReadonlyMap<string, AiToolPresentation>;
     /** Mutable call-id set read only when a rejected tool result is persisted. */
     rejectedToolCallIds?: ReadonlySet<string>;
+    /** Mutable call-id set read only when the result of a call the user approved is persisted. */
+    approvedToolCallIds?: ReadonlySet<string>;
   }): SessionStore;
 };