@k2b/cloud 0.26.0 → 0.28.0

package/src/ai/chat/turn-view.tsx

@@ -1,4 +1,4 @@
-import { announce, Button, ButtonLink, Chat, useLocale } from "@k2b/ui";
+import { announce, Button, ButtonLink, Chat, NoticeCard, useLocale } from "@k2b/ui";
 import {
   type Accessor,
   createEffect,
@@ -15,7 +15,8 @@ import {
   untrack,
 } from "solid-js";
 import { markdown } from "../../shared";
-import type { AiTurnBlock } from "../protocol";
+import { AI_TURN_LEASE_MS, type AiTurnBlock } from "../protocol";
+import type { AiTurnError } from "../types";
 import { ApprovalBlockView, CompactionBlockView, CompactToolRow, SurveyToolView, TextEditorToolView } from "./blocks";
 import { CapabilityTablePreview } from "./capability-table";
 import { PresentToolBlock } from "./file-tools";
@@ -25,6 +26,7 @@ import { aiChatMessages } from "./messages";
 import { AssistantMarkdownBlock } from "./primitives";
 import { AiToolActivity, AiToolDisclosureProvider, type AiToolDisclosureState } from "./tool-disclosure";
 import { type AiWorkEntry, countWorkSteps, groupWorkBlocks, summarizeToolGroup } from "./tool-groups";
+import { aiTurnErrorCanContinue, aiTurnErrorDescription } from "./turn-error";
 import type { AiTurnAction, AiTurnLayout, AiTurnPhase, AiTurnResult } from "./turn-layout";
 import { CloudCardBlock } from "./visual-tools";
 
@@ -47,8 +49,16 @@ export type AiTurnSegment = {
   duration: () => AiTurnDuration | null;
   /** Shown above the work of a delivered scheduled result. */
   scheduledTask?: { taskId: string; occurrenceId: string } | null;
-  /** A model call of the live turn waits for its retry. Set on the turn's last segment, so the wait ends the turn. */
-  retrying?: boolean;
+  /**
+   * The live turn cannot reach the model or the server right now: a model call waits for its retry, or the stream
+   * reconnects. The working segment's work line says so while its clock stands; a turn without a work line yet says
+   * it in a row at the end of its last segment.
+   */
+  reconnect?: "line" | "row";
+  /** Why the turn failed, shown in a notice at its end. Only the last segment of a failed turn carries it. */
+  error?: AiTurnError | null;
+  /** The failed turn is the chat's newest and nothing runs, so a new message can pick up its work. */
+  continuable?: boolean;
 };
 
 const isLive = (phase: AiTurnPhase) => phase === "running" || phase === "waiting";
@@ -63,6 +73,10 @@ export const formatWorkDuration = (ms: number, t: Messages, long = false): strin
   return long ? t.durationHoursLong({ hours, minutes: minutes % 60 }) : t.durationHours({ hours, minutes: minutes % 60 });
 };
 
+/** Identity of the current step: it changes when another block becomes current or the current call changes state. */
+const stepKey = (block: AiTurnBlock | null): string =>
+  !block ? "start" : `${block.id}:${block.kind === "tool" || block.kind === "compaction" ? block.status : block.kind}`;
+
 /** A running clock: "2:41", "1:02:41". */
 export const formatWorkClock = (ms: number): string => {
   const total = Math.max(0, Math.floor(ms / 1000));
@@ -80,14 +94,25 @@ const toolTarget = (block: ToolBlock): string => {
   return typeof value === "string" ? basename(value.trim()) : "";
 };
 
-/** The current step of a live turn, as a short progressive phrase. */
-export const liveStepLabel = (block: AiTurnBlock | null, t: Messages): string => {
+/** A step that runs longer than this shows its duration, so a long step does not look like a stalled one. */
+export const AI_LONG_STEP_MS = AI_TURN_LEASE_MS;
+
+/**
+ * The current step of a live turn, as a short progressive phrase. A step that runs long shows its duration in place of
+ * its target: "Running code · 3 min".
+ */
+export const liveStepLabel = (block: AiTurnBlock | null, t: Messages, stepMs = 0): string => {
+  if (stepMs < AI_LONG_STEP_MS) return stepPhrase(block, t, true);
+  return `${stepPhrase(block, t, false)} · ${formatWorkDuration(stepMs, t)}`;
+};
+
+const stepPhrase = (block: AiTurnBlock | null, t: Messages, withTargets: boolean): string => {
   if (!block || block.kind === "thinking" || block.kind === "steer_applied" || block.kind === "steer_message") return t.stepThinking;
   if (block.kind === "text") return t.stepWriting;
   if (block.kind === "compaction") return block.status === "running" ? t.stepCompacting : t.stepThinking;
   // A finished call means the model is deciding what to do next.
   if (block.status !== "running" && block.status !== "awaiting_client") return t.stepThinking;
-  const target = toolTarget(block);
+  const target = withTargets ? toolTarget(block) : "";
   const withTarget = (label: string) => (target ? `${label} · ${target}` : label);
   const name = block.name;
   if (block.presentation?.kind === "capability") return withTarget(t.stepUsingApp({ app: block.presentation.appName }));
@@ -102,7 +127,7 @@ export const liveStepLabel = (block: AiTurnBlock | null, t: Messages): string =>
   if (["code_write", "code_create", "code_update", "code_fork", "code_remove", "code_restore"].includes(name))
     return withTarget(t.stepWritingCode);
   if (["code_run", "code_action", "code_sql"].includes(name)) return withTarget(t.stepRunningCode);
-  if (["code_inspect", "code_interact"].includes(name)) return t.stepCheckingApp;
+  if (name === "code_inspect") return t.stepCheckingApp;
   if (name.startsWith("code_")) return t.stepCode;
   if (["markdown_to_pdf", "html_to_pdf"].includes(name)) return withTarget(t.stepPdf);
   if (["load_skill", "load_tools", "search_tools", "list_apps"].includes(name)) return t.stepLoading;
@@ -117,20 +142,37 @@ function AiWorkLine(props: { segment: Accessor<AiTurnSegment> }) {
   const t = () => aiChatMessages(locale());
   const segment = () => props.segment();
   const layout = () => segment().layout;
-  const waiting = () => segment().phase === "waiting" && layout().waitingFor !== null;
-  const working = () => isLive(segment().phase) && !waiting();
+  const reconnecting = () => isLive(segment().phase) && segment().reconnect === "line";
+  const waiting = () => !reconnecting() && segment().phase === "waiting" && layout().waitingFor !== null;
+  const working = () => isLive(segment().phase) && !waiting() && !reconnecting();
+  // The current step is timed on the work clock, so it stands while the turn reconnects.
+  const currentStep = createMemo(() => (isLive(segment().phase) ? stepKey(layout().current) : null));
+  const step = createMemo(on(currentStep, (key) => (key === null ? null : (untrack(segment().duration)?.workedMs ?? 0))));
+  const stepMs = () => {
+    const startedAt = step();
+    const workedMs = segment().duration()?.workedMs;
+    return startedAt === null || workedMs === undefined ? 0 : workedMs - startedAt;
+  };
+  // Screen readers hear once that the turn reconnects; the line itself is not read while it changes.
+  createEffect(
+    on(reconnecting, (now, before) => {
+      if (now && !before) announce(t().reconnecting);
+    }),
+  );
   const worked = () => {
     const duration = segment().duration();
     return !segment().earlier && duration && duration.workedMs > 0 ? duration.workedMs : null;
   };
   const steps = () => t().steps({ count: layout().steps });
   const label = () => {
-    if (working()) return liveStepLabel(layout().current, t());
+    if (reconnecting()) return t().reconnecting;
+    if (working()) return liveStepLabel(layout().current, t(), stepMs());
     if (waiting()) return layout().waitingFor === "approval" ? t().waitingForApproval : t().waitingForAnswer;
     const duration = worked();
     const short = duration === null ? "" : formatWorkDuration(duration, t());
     if (segment().phase === "stopped") return t().workedStopped({ duration: short });
-    if (segment().phase === "failed") return t().workedInterrupted({ duration: short });
+    // A failed turn with a stored reason says it in its notice; the line then reads like any finished turn.
+    if (segment().phase === "failed" && !segment().error) return t().workedInterrupted({ duration: short });
     return short ? t().workedFor({ duration: short }) : t().worked;
   };
   const ariaLabel = () => {
@@ -140,12 +182,12 @@ function AiWorkLine(props: { segment: Accessor<AiTurnSegment> }) {
     return t().workedLabel({
       duration: duration === null ? "" : formatWorkDuration(duration, t(), true),
       steps: layout().steps ? steps() : "",
-      ending: phase === "stopped" || phase === "failed" ? phase : null,
+      ending: phase === "stopped" || (phase === "failed" && !segment().error) ? phase : null,
     });
   };
   const trailing = () => {
     const duration = segment().duration();
-    if (working() && duration) {
+    if ((working() || reconnecting()) && duration) {
       return (
         <span class="ai-turn-work__meta">
           {formatWorkClock(duration.workedMs)}
@@ -487,6 +529,37 @@ function AiTurnActionView(props: { action: Accessor<AiTurnAction | undefined>; t
   );
 }
 
+/**
+ * Why a turn failed and what comes next, at its end. "Continue" sends a visible message through the host's normal
+ * send path, so the person sees what was asked; it is offered only for the chat's newest turn and only when a new
+ * turn can finish the work.
+ */
+function AiTurnErrorNotice(props: { error: AiTurnError; continuable: boolean }) {
+  const locale = useLocale();
+  const t = () => aiChatMessages(locale());
+  const actions = useAiChatActions();
+  const [continuing, setContinuing] = createSignal(false);
+  const canContinue = () => props.continuable && aiTurnErrorCanContinue(props.error) && Boolean(actions.onContinueTurn);
+  const continueTurn = async () => {
+    if (continuing()) return;
+    setContinuing(true);
+    try {
+      await actions.onContinueTurn?.(t().continueTurnMessage);
+    } finally {
+      setContinuing(false);
+    }
+  };
+  return (
+    <NoticeCard tone="danger" class="ai-turn__notice" title={t().turnErrorTitle} detail={aiTurnErrorDescription(props.error, locale())}>
+      <Show when={canContinue()}>
+        <Button variant="text" size="sm" loading={continuing()} disabled={actions.actionDisabled?.()} onClick={() => void continueTurn()}>
+          <i class="ti ti-player-play" aria-hidden="true" /> {t().continueTurn}
+        </Button>
+      </Show>
+    </NoticeCard>
+  );
+}
+
 /**
  * Place 3. Live it is a status that switches in this same element; it keeps its height until the turn ends. A status
  * is not read token by token: screen readers hear each status once it is complete, and that the answer is ready.
@@ -570,6 +643,16 @@ export function AiTurnView(props: { segment: Accessor<AiTurnSegment>; disclosure
   const actions = createMemo(() => new Map(layout().actions.map((action) => [action.id, action])));
   const actionIds = createMemo(() => [...actions().keys()]);
   const live = () => isLive(props.segment().phase);
+  // Screen readers hear once that the turn they followed failed and why; history read later is not announced.
+  createEffect(
+    on(live, (now, before) => {
+      const error = props.segment().error;
+      if (before && !now && error) {
+        const t = aiChatMessages(locale());
+        announce(`${t.turnErrorTitle} ${aiTurnErrorDescription(error, locale())}`);
+      }
+    }),
+  );
   return (
     <AiToolDisclosureProvider state={props.disclosureState}>
       <div class="ai-turn">
@@ -599,10 +682,13 @@ export function AiTurnView(props: { segment: Accessor<AiTurnSegment>; disclosure
         <For each={actionIds()}>
           {(id) => <AiTurnActionView action={() => actions().get(id)} turnId={props.segment().turnId} phase={props.segment().phase} />}
         </For>
-        <Show when={props.segment().retrying}>
-          {/* Calm by design: no busy sweep while the model call waits for its retry. */}
+        <Show when={props.segment().reconnect === "row"}>
+          {/* Calm by design: no busy sweep while the turn reconnects. */}
           <Chat.Activity label={aiChatMessages(locale()).reconnecting} icon="ti ti-refresh" />
         </Show>
+        <Show when={props.segment().error}>
+          {(error) => <AiTurnErrorNotice error={error()} continuable={props.segment().continuable === true} />}
+        </Show>
       </div>
     </AiToolDisclosureProvider>
   );

package/src/ai/chat/user-message.tsx

@@ -13,11 +13,14 @@ import {
   userVisibleTextFromMessage,
   vfsAttachmentsFromMessage,
 } from "./message-utils";
+import { aiChatMessages } from "./messages";
 
 const openModifyRetryDialog = (
   entry: AiStoredMessage,
   onRetryMessage: (entry: AiStoredMessage, input?: AiRetryMessageInput) => void | Promise<void>,
+  locale: string,
 ) => {
+  const t = aiChatMessages(locale);
   void dialogCore.open<void>((close) => {
     const [draft, setDraft] = createSignal(userVisibleTextFromMessage(entry.message));
     const content = () => userContentWithEditedVisibleText(entry.message, draft());
@@ -34,11 +37,11 @@ const openModifyRetryDialog = (
 
     return (
       <PanelDialog>
-        <PanelDialog.Header title="Edit and try again" icon="ti ti-pencil" close={close} />
+        <PanelDialog.Header title={t.retryTitle} icon="ti ti-pencil" close={close} />
         <PanelDialog.Body>
           <TextInput
-            label="Prompt"
-            description="Attachments from the original message stay attached."
+            label={t.retryPrompt}
+            description={t.retryPromptHint}
             multiline
             lines={8}
             value={draft}
@@ -47,18 +50,18 @@ const openModifyRetryDialog = (
           />
           <Show when={retryMutation.error()}>
             <p class="text-xs text-red-600 dark:text-red-400" role="alert">
-              Could not retry this message. Your changes are still here.
+              {t.retryFailed}
             </p>
           </Show>
         </PanelDialog.Body>
         <PanelDialog.Footer>
           <div class="ml-auto flex items-center gap-2">
             <Button type="button" variant="secondary" size="sm" onClick={() => close()}>
-              Cancel
+              {t.cancel}
             </Button>
             <Button type="button" variant="ai" size="sm" disabled={!canRetry()} onClick={retry}>
               <i class={`ti ${retryMutation.loading() ? "ti-loader-2 animate-spin" : "ti-refresh"}`} aria-hidden="true" />
-              {retryMutation.loading() ? "Trying again" : "Try again"}
+              {retryMutation.loading() ? t.retrying : t.actionTryAgain}
             </Button>
           </div>
         </PanelDialog.Footer>
@@ -93,38 +96,39 @@ export const aiUserMessageAttachments = (entry: AiStoredMessage, actions: AiChat
   })),
 ];
 
-export const createAiUserMessageActions = (entry: AiStoredMessage, actions: AiChatActions): ChatAction[] => {
+export const createAiUserMessageActions = (entry: AiStoredMessage, actions: AiChatActions, locale: string): ChatAction[] => {
+  const t = aiChatMessages(locale);
   const result: ChatAction[] = [];
   const copyText = copyTextFromMessage(entry.message);
 
   if (copyText) {
-    result.push({ id: "copy", label: "Copy", icon: "ti ti-copy", copyText });
+    result.push({ id: "copy", label: t.actionCopy, icon: "ti ti-copy", copyText });
   }
   if (!entry.compactedAt && actions.onRetryMessage) {
     result.push(
       {
         id: "retry",
-        label: "Try again",
+        label: t.actionTryAgain,
         icon: "ti ti-refresh",
         onSelect: () => actions.onRetryMessage?.(entry, { mode: "retry" }),
       },
       {
         id: "details",
-        label: "More detailed",
+        label: t.actionMoreDetailed,
         icon: "ti ti-list-details",
         onSelect: () => actions.onRetryMessage?.(entry, { mode: "details" }),
       },
       {
         id: "concise",
-        label: "More concise",
+        label: t.actionMoreConcise,
         icon: "ti ti-align-left",
         onSelect: () => actions.onRetryMessage?.(entry, { mode: "concise" }),
       },
       {
         id: "edit",
-        label: "Edit prompt",
+        label: t.actionEditPrompt,
         icon: "ti ti-pencil",
-        onSelect: () => openModifyRetryDialog(entry, actions.onRetryMessage!),
+        onSelect: () => openModifyRetryDialog(entry, actions.onRetryMessage!, locale),
       },
     );
   }
@@ -136,12 +140,13 @@ export const aiSteerMessageText = (block: Extract<AiTurnBlock, { kind: "steer_me
 export const createAiSteerMessageActions = (
   block: Extract<AiTurnBlock, { kind: "steer_message" }>,
   actions: AiChatActions,
+  locale: string,
 ): ChatAction[] => {
   if (block.status !== "failed" || !actions.onRetrySteer) return [];
   return [
     {
       id: "retry-steer",
-      label: "Retry guidance",
+      label: aiChatMessages(locale).actionRetryGuidance,
       icon: "ti ti-refresh",
       onSelect: () => actions.onRetrySteer?.(block),
     },

package/src/ai/chat/visual-tools.tsx

@@ -228,7 +228,7 @@ export function CloudSurveyBlock(props: {
           </Show>
         </div>
       </div>
-      <footer class="flex min-h-12 items-center gap-3 border-t border-[var(--k2b-border)] bg-[var(--k2b-surface-subtle)] px-4 py-2.5">
+      <footer class="flex min-h-12 items-center gap-3 px-4 pb-3">
         <Show when={submitted()}>
           <span class="inline-flex items-center gap-1.5 text-xs font-medium text-secondary">
             <i class="ti ti-check text-[var(--k2b-ai-accent)]" aria-hidden="true" />

package/src/ai/client/controller.ts

@@ -2,7 +2,7 @@ import { type Accessor, createMemo, createSignal, onCleanup } from "solid-js";
 import { createStore, reconcile } from "solid-js/store";
 import { type AiAttachmentRef, aiAttachmentMarker } from "../attachments";
 import { aiChatMessages } from "../chat/messages";
-import { type AiStreamEvent, type AiTurnBlock, type AiTurnSnapshot, steerMessageBlockId } from "../protocol";
+import { AI_TURN_LEASE_MS, type AiStreamEvent, type AiTurnBlock, type AiTurnSnapshot, steerMessageBlockId } from "../protocol";
 import { type AiResourceMarker, aiResourceMarker } from "../resource-markers";
 import type {
   AiClientToolId,
@@ -94,13 +94,26 @@ const isCurrentStreamSession = (current: AiStreamSession | null, candidate: AiSt
 
 const DEFAULT_RUN_ERROR = "Assistant response failed.";
 
-const conversationRunError = (conversation: AiConversation | null | undefined): string | null =>
-  conversation?.runStatus === "failed" ? conversation.runError?.trim() || DEFAULT_RUN_ERROR : null;
+/** The failure of the chat's latest turn, and that turn when known. */
+type AiRunError = { message: string; turnId: string | null };
 
-const runErrorFromEvent = (event: AiStreamEvent, activeTurnId: string | null | undefined): string | null | undefined => {
+const conversationRunError = (conversation: AiConversation | null | undefined): AiRunError | null =>
+  conversation?.runStatus === "failed"
+    ? { message: conversation.runError?.trim() || DEFAULT_RUN_ERROR, turnId: conversation.runTurnId ?? null }
+    : null;
+
+/**
+ * Whether the failed turn shows its failure itself: its last message carries the reason, and the timeline words it in
+ * a notice at the turn's end. The run error then stays out of `error()`, so it does not appear twice. A turn without a
+ * recorded reason, such as a failed compaction or a turn from an earlier release, still reports it there.
+ */
+const turnShowsError = (messages: readonly AiStoredMessage[], turnId: string | null): boolean =>
+  turnId !== null && messages.some((message) => message.loopId === turnId && message.meta?.turnError);
+
+const runErrorFromEvent = (event: AiStreamEvent, activeTurnId: string | null | undefined): AiRunError | null | undefined => {
   if (event.type === "state") return conversationRunError(event.conversation);
   if (event.type !== "turn_finished" || event.turnId !== activeTurnId) return undefined;
-  return event.status === "failed" ? event.error?.trim() || DEFAULT_RUN_ERROR : null;
+  return event.status === "failed" ? { message: event.error?.trim() || DEFAULT_RUN_ERROR, turnId: event.turnId } : null;
 };
 
 export type CreateAiChatControllerOptions = {
@@ -168,7 +181,7 @@ const errorText = (error: unknown, fallback: string): string =>
 export const createAiChatController = (options: CreateAiChatControllerOptions) => {
   const [activeConversationId, setActiveConversationIdSignal] = createSignal<string | null>(options.initialConversationId ?? null);
   const [globalError, setGlobalError] = createSignal<string | null>(options.initialError ?? null);
-  const [runError, setRunError] = createSignal<string | null>(conversationRunError(options.initialDetail?.conversation));
+  const [runError, setRunError] = createSignal<AiRunError | null>(conversationRunError(options.initialDetail?.conversation));
   const [runStatusRaw, setRunStatusRaw] = createSignal<AiChatRunStatus | null>(null);
   const [streamStatus, setStreamStatus] = createSignal<AiStreamStatus>("idle");
   const initialProjection = options.initialDetail ? detailToProjection(options.initialDetail) : emptyProjection();
@@ -201,6 +214,7 @@ export const createAiChatController = (options: CreateAiChatControllerOptions) =
   const abortRequests = new Map<string, Promise<boolean>>();
   let stream: AiStreamHandle | null = null;
   let streamSession: AiStreamSession | null = null;
+  let silenceTimer: ReturnType<typeof setTimeout> | undefined;
   /** The chat error left by a stream that ended for good, until a stream opens again. */
   let streamError: string | null = null;
   let streamGeneration = 0;
@@ -249,7 +263,10 @@ export const createAiChatController = (options: CreateAiChatControllerOptions) =
     const conversationId = activeConversationId();
     if (conversationId) openStream(conversationId);
   };
-  const error = () => globalError() ?? runError();
+  const error = () => {
+    const run = runError();
+    return globalError() ?? (run && !turnShowsError(state.messages, run.turnId) ? run.message : null);
+  };
 
   const activeTurn = () => state.activeTurn;
   const messages = createMemo(() => messagesWithPendingSend(visibleMessages(state), pendingSends()[activeConversationId() ?? ""]));
@@ -294,8 +311,32 @@ export const createAiChatController = (options: CreateAiChatControllerOptions) =
     void markConversationViewed(session.conversationId);
   };
 
+  const clearSilenceTimer = () => {
+    if (silenceTimer) clearTimeout(silenceTimer);
+    silenceTimer = undefined;
+  };
+
+  /**
+   * A running turn whose open stream delivers nothing for one worker lease either works silently or lost an update,
+   * such as its end. The stream then starts again from the turn's saved state. The wait starts with the stream's
+   * first event, so a slow first state is never cut off. A turn that waits for an action in this browser is not
+   * silent, and a stream that reconnects brings a fresh state anyway.
+   */
+  const watchSilence = (session: AiStreamSession) => {
+    clearSilenceTimer();
+    silenceTimer = setTimeout(() => {
+      silenceTimer = undefined;
+      if (!isCurrentStreamSession(streamSession, session)) return;
+      const status = streamStatus();
+      if (state.activeTurn?.status !== "running" || status === "connecting" || status === "reconnecting") return watchSilence(session);
+      closeStream();
+      openStream(session.conversationId);
+    }, AI_TURN_LEASE_MS);
+  };
+
   const applyEvent = (session: AiStreamSession, event: AiStreamEvent) => {
     if (!isCurrentStreamSession(streamSession, session)) return;
+    watchSilence(session);
     const conversationId = session.conversationId;
     if (event.type === "turn_finished" && pendingSends()[conversationId]) {
       completedDuringSend.set(conversationId, event.turnId);
@@ -327,6 +368,7 @@ export const createAiChatController = (options: CreateAiChatControllerOptions) =
   };
 
   const closeStream = () => {
+    clearSilenceTimer();
     stream?.close();
     stream = null;
     streamSession = null;
@@ -400,15 +442,15 @@ export const createAiChatController = (options: CreateAiChatControllerOptions) =
       console.warn(`No frontend handler registered for AI tool "${name}" — leaving the action request pending.`);
       return false;
     }
+    let result: unknown;
     try {
-      const result = await handler({ name, callId, args, turnId, conversationId });
-      return submitTurnActionForConversation(conversationId, turnId, callId, { type: "tool_result", result });
+      result = await handler({ name, callId, args, turnId, conversationId });
     } catch (toolError) {
-      return submitTurnActionForConversation(conversationId, turnId, callId, {
-        type: "tool_result",
-        result: { error: toolError instanceof Error ? toolError.message : "Frontend tool failed" },
-      });
+      result = { error: toolError instanceof Error ? toolError.message : "Frontend tool failed" };
     }
+    const submitted = await submitTurnActionForConversation(conversationId, turnId, callId, { type: "tool_result", result });
+    if (submitted) showActionResolved(conversationId, turnId, { type: "tool_result", callId, result });
+    return submitted;
   };
 
   // ---- conversation loading --------------------------------------------
@@ -1258,6 +1300,28 @@ export const createAiChatController = (options: CreateAiChatControllerOptions) =
     }
   };
 
+  /**
+   * Shows an action the server accepted as resolved, so the turn runs on before the stream confirms it. A turn that
+   * runs is watched for silence again, which heals a confirmation that never arrives.
+   */
+  const showActionResolved = (
+    conversationId: string,
+    turnId: string,
+    action: { type: "approval_response"; callId: string; approved: boolean } | { type: "tool_result"; callId: string; result: unknown },
+  ) => {
+    if (!isActiveConversation(conversationId) || state.activeTurn?.turnId !== turnId) return;
+    const waitingStatus = action.type === "approval_response" ? "awaiting_approval" : "awaiting_client";
+    setState("activeTurn", (current) => {
+      if (!current || current.turnId !== turnId) return current;
+      const pending = current.blocks.some(
+        (block) => block.kind === "tool" && block.callId === action.callId && block.status === waitingStatus,
+      );
+      if (!pending) return current;
+      return reconcileActiveTurnActions(current, [{ callId: action.callId, resolvedEvent: action }]);
+    });
+    cache.set(conversationId, { conversation: state.conversation, messages: state.messages, activeTurn: state.activeTurn });
+  };
+
   const submitTurnAction = (
     turnId: string,
     callId: string,
@@ -1277,18 +1341,9 @@ export const createAiChatController = (options: CreateAiChatControllerOptions) =
       approved: input.approved,
       remember: input.remember,
     });
-    if (!submitted || !isActiveConversation(conversationId) || state.activeTurn?.turnId !== request.turnId) return submitted;
-    const action = { type: "approval_response" as const, callId: request.callId, approved: input.approved };
-    setState("activeTurn", (current) => {
-      if (!current || current.turnId !== request.turnId) return current;
-      const pending = current.blocks.some(
-        (block) => block.kind === "tool" && block.callId === request.callId && block.status === "awaiting_approval",
-      );
-      if (!pending) return current;
-      return reconcileActiveTurnActions(current, [{ callId: request.callId, resolvedEvent: action }]);
-    });
-    cache.set(conversationId, { conversation: state.conversation, messages: state.messages, activeTurn: state.activeTurn });
-    return true;
+    if (submitted)
+      showActionResolved(conversationId, request.turnId, { type: "approval_response", callId: request.callId, approved: input.approved });
+    return submitted;
   };
 
   const submitFrontendToolResult = async (request: { turnId: string; callId: string }, result: unknown) => {
@@ -1299,18 +1354,8 @@ export const createAiChatController = (options: CreateAiChatControllerOptions) =
       type: "tool_result",
       result,
     });
-    if (!submitted || !isActiveConversation(conversationId) || state.activeTurn?.turnId !== request.turnId) return submitted;
-    const action = { type: "tool_result" as const, callId: request.callId, result };
-    setState("activeTurn", (current) => {
-      if (!current || current.turnId !== request.turnId) return current;
-      const pending = current.blocks.some(
-        (block) => block.kind === "tool" && block.callId === request.callId && block.status === "awaiting_client",
-      );
-      if (!pending) return current;
-      return reconcileActiveTurnActions(current, [{ callId: request.callId, resolvedEvent: action }]);
-    });
-    cache.set(conversationId, { conversation: state.conversation, messages: state.messages, activeTurn: state.activeTurn });
-    return true;
+    if (submitted) showActionResolved(conversationId, request.turnId, { type: "tool_result", callId: request.callId, result });
+    return submitted;
   };
 
   if (options.initialConversationId) {
@@ -1386,6 +1431,7 @@ export const __aiControllerTest = {
   completeFrontendToolBlock,
   conversationRunError,
   failSteerBlock,
+  turnShowsError,
   projectionForConversationOpen,
   reconcileSteerBlocks,
   runErrorFromEvent,

package/src/ai/client/file-source.ts

@@ -30,7 +30,14 @@ const bytesToBase64 = (bytes: Uint8Array): string => {
   return btoa(binary);
 };
 
-export const conversationFileSource = (baseUrl: string, conversationId: string): FileSource & { listFiles(): Promise<AiFileStat[]> } => {
+export type ConversationFileSource = FileSource & {
+  /** Files below `prefix` (default `/`); with `page`, at most `page.limit` files by path after `page.after`. */
+  listFiles(prefix?: string, page?: { limit: number; after?: string }): Promise<AiFileStat[]>;
+  /** Delete a folder with everything below it. */
+  removeFolder(path: string): Promise<void>;
+};
+
+export const conversationFileSource = (baseUrl: string, conversationId: string): ConversationFileSource => {
   const filesUrl = (suffix = "", params?: Record<string, string>) => {
     const query = params ? `?${new URLSearchParams(params).toString()}` : "";
     return `${baseUrl}/conversations/${conversationId}/files${suffix}${query}`;
@@ -45,8 +52,14 @@ export const conversationFileSource = (baseUrl: string, conversationId: string):
     return (await response.json()) as T;
   };
 
-  const listFiles = async (): Promise<AiFileStat[]> =>
-    (await request<{ files: AiFileStat[] }>(filesUrl(), { method: "GET" }, "Failed to load files")).files;
+  const listFiles = async (prefix?: string, page?: { limit: number; after?: string }): Promise<AiFileStat[]> => {
+    const params: Record<string, string> = {
+      ...(prefix ? { prefix } : {}),
+      ...(page ? { limit: String(page.limit), ...(page.after ? { after: page.after } : {}) } : {}),
+    };
+    const url = Object.keys(params).length ? filesUrl("", params) : filesUrl();
+    return (await request<{ files: AiFileStat[] }>(url, { method: "GET" }, "Failed to load files")).files;
+  };
 
   return {
     previewPreferencesKey: "assistant.csv-preview",
@@ -80,6 +93,10 @@ export const conversationFileSource = (baseUrl: string, conversationId: string):
       await request(filesUrl("", { path }), { method: "DELETE" }, "Failed to delete file");
     },
 
+    async removeFolder(path) {
+      await request(filesUrl("", { path, recursive: "true" }), { method: "DELETE" }, "Failed to delete folder");
+    },
+
     async rename(from, to) {
       await request(filesUrl("/rename"), { method: "POST", body: JSON.stringify({ from, to }) }, "Failed to rename file");
     },

package/src/ai/client/projection.ts

@@ -9,7 +9,10 @@ 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. */
+  /**
+   * A model call failed transiently and waits for its retry. Live only: the next turn event ends it, and so does a
+   * snapshot that has moved past the retry.
+   */
   providerRetry?: boolean;
   /** Server start of the turn, known from a state snapshot. */
   createdAt?: string;
@@ -98,7 +101,9 @@ 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 { ...turnTiming(previous), ...incoming, blocks, status: deriveStatus(blocks) };
+  // A snapshot never carries a provider retry. One at the retry's own position has seen nothing after it, so the wait goes on.
+  const retry = previous.providerRetry && incoming.seq === previous.seq ? { providerRetry: true } : {};
+  return { ...turnTiming(previous), ...incoming, ...retry, blocks, status: deriveStatus(blocks) };
 };
 
 export const reconcileActiveTurnActions = (