@k2b/cloud 0.28.0 → 0.29.1

package/src/ai/chat/live-turn.browser-harness.tsx

@@ -10,14 +10,20 @@ import { AiChatActionsProvider, createAiChatTimeline } from "./presentation";
  * The live chat timeline for a browser test, folded from wire events like the
  * controller does. `window.emit(event)` applies one event,
  * `window.steer(text)` appends a pending steer as the controller does,
- * `window.reconnect(on)` sets whether the stream reconnects, and
- * `window.continued` lists the messages that **Continue** sent.
+ * `window.reconnect(on)` sets whether the stream reconnects,
+ * `window.continued` lists the messages that **Continue** sent,
+ * `window.approvals` lists the approval decisions, and
+ * `window.opened` lists the chat files the timeline opened. Chat files load from `/files?path=`.
  */
 const [state, setState] = createStore(emptyProjection());
 const [reconnecting, setReconnecting] = createSignal(false);
 const continued: string[] = [];
+const opened: string[] = [];
+const approvals: unknown[] = [];
 Object.assign(window, {
   continued,
+  approvals,
+  opened,
   reconnect: (on: boolean) => setReconnecting(on),
   emit: (event: AiWireEvent) => setState(reconcile(reduceProjection(state, event), { key: "id", merge: true })),
   steer: (text: string) =>
@@ -32,7 +38,14 @@ root.style.cssText = "display: flex; flex-direction: column; height: 100dvh; max
 document.body.append(root);
 render(
   () => (
-    <AiChatActionsProvider actions={{ onContinueTurn: (message) => void continued.push(message) }}>
+    <AiChatActionsProvider
+      actions={{
+        onContinueTurn: (message) => void continued.push(message),
+        onApproval: async (request, input) => void approvals.push({ callId: request.callId, ...input }),
+        fileUrl: (path) => `/files?path=${encodeURIComponent(path)}`,
+        onOpenFile: (path) => void opened.push(path),
+      }}
+    >
       {(() => {
         const items = createAiChatTimeline({
           messages: createMemo(() => visibleMessages(state)),

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

@@ -218,7 +218,7 @@ const openAssistantResponseInfo = (entries: AiStoredMessage[], locale: string) =
                   {(tool) => (
                     <li>
                       <i class={aiToolIcon(tool.name)} aria-hidden="true" />
-                      {displayToolName(tool.name)}
+                      {displayToolName(tool.name, locale)}
                       <Show when={tool.count > 1}>
                         <span class="text-dimmed tabular-nums">×{tool.count}</span>
                       </Show>

package/src/ai/chat/message-utils.ts

@@ -3,12 +3,14 @@ import { fileIcons } from "@k2b/stdlib";
 import { formatBytes as sharedFormatBytes } from "../../shared/format";
 import { type AiAttachmentRef, parseAiAttachmentMarkers } from "../attachments";
 import { AI_AUDIO_EXTENSIONS } from "../audio-format";
+import { aiProjectFilePathFromMount, aiSkillFilePathFromMount } from "../file-mount";
 import { AI_IMAGE_INPUT_MAX_BYTES, AI_TURN_ATTACHMENT_MAX_ITEMS } from "../limits";
 import { type AiResourceMarker, parseAiResourceMarker } from "../resource-markers";
 import { assistantVisibleTextFromMessage } from "../timeline";
 import type { AiStoredMessage, AiUserContentPart } from "../types";
 import { AI_IMAGE_MEDIA_TYPES, isAiImageMediaType } from "../types";
 import { aiChatMessages } from "./messages";
+import { aiBuiltinToolName } from "./tool-names";
 
 type AssistantToolResultMessage = Extract<Message, { role: "tool_result" }>;
 
@@ -144,8 +146,9 @@ export const describeResponseEnd = (entry: Pick<AiStoredMessage, "loopDoneReason
     interrupted: t.infoEndInterrupted,
     error: t.infoEndFailed,
   };
+  const stopped = entry.stopReason && ["error", "aborted", "interrupted"].includes(entry.stopReason);
   const parts = [
-    entry.loopDoneReason ? run[entry.loopDoneReason] : null,
+    entry.loopDoneReason && !(entry.loopDoneReason === "stop" && stopped) ? run[entry.loopDoneReason] : null,
     entry.stopReason ? (Object.hasOwn(message, entry.stopReason) ? message[entry.stopReason] : entry.stopReason) : null,
   ].filter((part): part is string => Boolean(part));
   return [...new Set(parts)].join(" · ") || t.infoUnknown;
@@ -312,11 +315,10 @@ export const isSurveyToolName = (name: string) => name === "survey" || name ===
 
 export const isTextEditorToolName = (name: string) => name === "text_editor" || name === "cloud_text_editor";
 
-export const displayToolName = (name: string) => {
-  if (isCardToolName(name)) return "card";
-  if (isSurveyToolName(name)) return "survey";
-  if (isTextEditorToolName(name)) return "text editor";
-  if (name === "local_bash") return "Local Bash";
+/** A tool's name for people: the localized name of a built-in tool, otherwise its name in words. */
+export const displayToolName = (name: string, locale: string) => {
+  const builtin = aiBuiltinToolName(name, locale);
+  if (builtin) return builtin;
   const words = name.split("_").filter(Boolean).join(" ");
   return `${words.slice(0, 1).toUpperCase()}${words.slice(1)}`;
 };
@@ -340,6 +342,7 @@ const BUILT_IN_TOOL_ICONS = new Map<string, string>([
   ["web_search", "ti ti-search"],
   ["web_extract", "ti ti-world-download"],
   ["view_image", "ti ti-photo-spark"],
+  ["code_check", "ti ti-checklist"],
   ["memory", "ti ti-brain"],
   ["search_project", "ti ti-folder-search"],
   ["read_project_knowledge", "ti ti-notebook"],
@@ -353,6 +356,25 @@ const BUILT_IN_TOOL_ICONS = new Map<string, string>([
   ["read_cloud_resource", "ti ti-ai-gateway"],
 ]);
 
+/** What an app check found: errors stop it from passing, warnings are counted separately. */
+export type AiCodeCheckOutcome = { passed: boolean; errors: number; warnings: number };
+
+export const codeCheckOutcome = (name: string, result: unknown): AiCodeCheckOutcome | null => {
+  if (name !== "code_check" || !isRecord(result) || typeof result.passed !== "boolean") return null;
+  const issues = Array.isArray(result.issues) ? result.issues.filter(isRecord) : [];
+  const warnings = issues.filter((issue) => issue.severity === "warning").length;
+  return { passed: result.passed, errors: issues.length - warnings, warnings };
+};
+
+/** The chat image a view_image call looked at. Project and skill files are not chat files and have no preview here. */
+export const viewedChatImage = (name: string, result: unknown): { path: string; description: string } | null => {
+  if (name !== "view_image" || !isRecord(result)) return null;
+  const { path, mediaType, description } = result;
+  if (typeof path !== "string" || typeof mediaType !== "string" || !isAiImageMediaType(mediaType)) return null;
+  if (aiProjectFilePathFromMount(path) !== null || aiSkillFilePathFromMount(path) !== null) return null;
+  return { path, description: typeof description === "string" ? description.trim() : "" };
+};
+
 export const aiToolIcon = (name: string, appIcon?: string | null): string => {
   if (appIcon) return appIcon;
   return BUILT_IN_TOOL_ICONS.get(name) ?? (/__(?:query|action)__/.test(name) ? "ti ti-ai-gateway" : "ti ti-tool");

package/src/ai/chat/messages.ts

@@ -25,6 +25,7 @@ const messages = i18n.define({
       turnErrorTitle: "The answer was interrupted.",
       turnErrorReason: ({ code, limitMinutes }: AiTurnError) => {
         if (code === "model_unavailable") return "The model service did not answer.";
+        if (code === "provider_stopped") return "The model provider ended this answer early.";
         if (code === "quota_exhausted") return "Your AI usage limit for this period is reached. You can continue once it resets.";
         if (code === "context_full") return "This chat is too long for the model. Start a new chat to continue; this one stays as it is.";
         if (code === "time_limit")
@@ -71,6 +72,7 @@ const messages = i18n.define({
       stepWritingCode: "Writing code",
       stepRunningCode: "Running code",
       stepCheckingApp: "Checking the app",
+      stepCheckingRun: "Checking the run",
       stepCode: "Working with code",
       stepPlan: "Updating the working plan",
       stepPdf: "Creating a PDF",
@@ -87,23 +89,18 @@ const messages = i18n.define({
       stepFailed: "failed",
       stepRejected: "rejected",
       stepWaiting: "waiting",
+      checkPassed: "passed",
+      checkNotPassed: "not passed",
+      checkFindings: ({ count }: { count: number }) => (count === 1 ? "1 finding" : `${count} findings`),
+      checkWarnings: ({ count }: { count: number }) => (count === 1 ? "1 warning" : `${count} warnings`),
+      openImage: ({ name }: { name: string }) => `Open image ${name}`,
       steered: "Conversation steered",
-      reasoning: "Reasoning",
-      groupPlan: "Updated working plan",
-      groupCode: "Worked with code",
-      groupCloud: "Used Cloud integration",
-      groupReadFiles: "Read files",
-      groupWriteFiles: "Wrote files",
-      groupPdf: "Created PDFs",
       groupLoad: "Loaded tools and guidance",
-      groupWeb: "Searched the web",
-      groupMemory: "Used memory",
-      groupDelivered: "Delivered results",
-      groupTools: "Used tools",
       groupFailed: ({ count }: { count: number }) => `${count} failed`,
       groupRejected: ({ count }: { count: number }) => `${count} rejected`,
       receiptDone: ({ title }: { title: string }) => `${title} done`,
       receiptApproved: ({ title }: { title: string }) => `Approved: ${title}`,
+      receiptRunning: ({ title }: { title: string }) => `Running: ${title}`,
       approvalNeeded: ({ title }: { title: string }) => `Approval needed: ${title}`,
       answerReady: "Answer ready",
       receiptRejected: ({ title }: { title: string }) => `Rejected: ${title}`,
@@ -114,7 +111,7 @@ const messages = i18n.define({
       streamAccessDenied: "You no longer have access to this chat.",
       streamNotFound: "This chat is no longer available.",
       assistant: "Assistant",
-      action: "Action",
+      approvalRunsAfter: "Runs only after you approve it",
       approvalRequired: ({ title }: { title: string }) => `Approval required: ${title}`,
       reject: "Reject",
       approved: "Approved",
@@ -286,6 +283,7 @@ const messages = i18n.define({
         `${count === 1 ? "1 message" : `${count} messages`} summarized · ${date}`,
       compactedHint: "From here on, the model sees this summary instead of the messages above.",
       compactedEmpty: "No visible content",
+      malformedImage: "This image could not be read. Export it again or choose another file.",
     },
     de: {
       backgroundRun: "Hintergrundlauf",
@@ -309,6 +307,7 @@ const messages = i18n.define({
       turnErrorTitle: "Die Antwort wurde abgebrochen.",
       turnErrorReason: ({ code, limitMinutes }) => {
         if (code === "model_unavailable") return "Der KI-Dienst hat nicht geantwortet.";
+        if (code === "provider_stopped") return "Der KI-Anbieter hat diese Antwort vorzeitig beendet.";
         if (code === "quota_exhausted")
           return "Dein KI-Kontingent für diesen Zeitraum ist aufgebraucht. Du kannst weiterarbeiten, sobald es sich erneuert.";
         if (code === "context_full")
@@ -361,6 +360,7 @@ const messages = i18n.define({
       stepWritingCode: "Schreibt Code",
       stepRunningCode: "Führt Code aus",
       stepCheckingApp: "Prüft die App",
+      stepCheckingRun: "Prüft den Lauf",
       stepCode: "Arbeitet mit Code",
       stepPlan: "Aktualisiert den Arbeitsplan",
       stepPdf: "Erstellt ein PDF",
@@ -377,23 +377,18 @@ const messages = i18n.define({
       stepFailed: "fehlgeschlagen",
       stepRejected: "abgelehnt",
       stepWaiting: "wartet",
+      checkPassed: "bestanden",
+      checkNotPassed: "nicht bestanden",
+      checkFindings: ({ count }) => (count === 1 ? "1 Befund" : `${count} Befunde`),
+      checkWarnings: ({ count }) => (count === 1 ? "1 Warnung" : `${count} Warnungen`),
+      openImage: ({ name }) => `Bild ${name} öffnen`,
       steered: "Richtung geändert",
-      reasoning: "Überlegungen",
-      groupPlan: "Arbeitsplan aktualisiert",
-      groupCode: "Mit Code gearbeitet",
-      groupCloud: "Cloud-Integration verwendet",
-      groupReadFiles: "Dateien gelesen",
-      groupWriteFiles: "Dateien geschrieben",
-      groupPdf: "PDFs erstellt",
       groupLoad: "Werkzeuge und Wissen geladen",
-      groupWeb: "Im Web recherchiert",
-      groupMemory: "Gedächtnis genutzt",
-      groupDelivered: "Ergebnisse bereitgestellt",
-      groupTools: "Werkzeuge verwendet",
       groupFailed: ({ count }) => `${count} fehlgeschlagen`,
       groupRejected: ({ count }) => `${count} abgelehnt`,
       receiptDone: ({ title }) => `${title} erledigt`,
       receiptApproved: ({ title }) => `Freigegeben: ${title}`,
+      receiptRunning: ({ title }) => `Wird ausgeführt: ${title}`,
       approvalNeeded: ({ title }) => `Freigabe nötig: ${title}`,
       answerReady: "Antwort fertig",
       receiptRejected: ({ title }) => `Abgelehnt: ${title}`,
@@ -404,7 +399,7 @@ const messages = i18n.define({
       streamAccessDenied: "Du hast keinen Zugriff mehr auf diesen Chat.",
       streamNotFound: "Dieser Chat ist nicht mehr verfügbar.",
       assistant: "Assistent",
-      action: "Aktion",
+      approvalRunsAfter: "Wird erst nach deiner Freigabe ausgeführt",
       approvalRequired: ({ title }) => `Freigabe erforderlich: ${title}`,
       reject: "Ablehnen",
       approved: "Freigegeben",
@@ -575,6 +570,7 @@ const messages = i18n.define({
       compactedCount: ({ count, date }) => `${count === 1 ? "1 Nachricht" : `${count} Nachrichten`} zusammengefasst · ${date}`,
       compactedHint: "Ab hier sieht das Modell diese Zusammenfassung statt der Nachrichten darüber.",
       compactedEmpty: "Kein sichtbarer Inhalt",
+      malformedImage: "Dieses Bild konnte nicht gelesen werden. Exportiere es erneut oder wähle eine andere Datei.",
     },
   },
 });

package/src/ai/chat/presentation.tsx

@@ -20,7 +20,7 @@ import { type AiChatActions, AiChatActionsProvider, createAssistantMessageAction
 import { isRecord, isSurveyToolName, textFromMessage } from "./message-utils";
 import { aiChatMessages } from "./messages";
 import { type AiToolDisclosureState, createAiToolDisclosureState } from "./tool-disclosure";
-import { type AiTurnLayout, type AiTurnPhase, layoutAiTurn, waitsForUser } from "./turn-layout";
+import { type AiTurnLayout, type AiTurnPhase, layoutAiTurn, storedPhase, waitsForUser } from "./turn-layout";
 import { TurnNavigator } from "./turn-navigator";
 import { activeTimelineSeq } from "./turn-navigator-utils";
 import { type AiTurnDuration, type AiTurnSegment, AiTurnView } from "./turn-view";
@@ -102,13 +102,6 @@ const leadingSteerOpener = (blocks: readonly AssistantBlock[]): string | null =>
   return opener;
 };
 
-/** History phase of a finished loop, from how its loop ended. */
-const storedPhase = (entries: readonly AiStoredMessage[]): AiTurnPhase => {
-  const reason = entries.findLast((entry) => entry.loopDoneReason)?.loopDoneReason;
-  if (!reason || reason === "stop") return "completed";
-  return reason === "aborted" ? "stopped" : "failed";
-};
-
 /** Responses with a work line, rich places, or a failure notice span the message column so their right edges align. */
 const isWideLayout = (layout: AiTurnLayout, error?: AiTurnError) =>
   layout.showWork || layout.results.length > 0 || layout.actions.length > 0 || Boolean(error);

package/src/ai/chat/tool-disclosure.tsx

@@ -1,28 +1,35 @@
 import { Chat, type ChatActivityProps } from "@k2b/ui";
-import { createContext, type JSX, splitProps, useContext } from "solid-js";
+import { createContext, createSignal, type JSX, type Signal, splitProps, useContext } from "solid-js";
 
 export type AiToolDisclosureState = {
   get: (blockId: string) => boolean | undefined;
   set: (blockId: string, open: boolean) => void;
 };
 
+/**
+ * Disclosure choices by block id. Reactive, so a disclosure that its reader opens renders its body at once, also when
+ * nothing else in the turn changes; choices survive a remount and, in session storage, a reload.
+ */
 export const createAiToolDisclosureState = (): AiToolDisclosureState => {
-  const openByBlockId = new Map<string, boolean>();
+  const signals = new Map<string, Signal<boolean | undefined>>();
   const storageKey = (blockId: string) => `cloud.ai.tool-disclosure:${blockId}`;
+  const signal = (blockId: string): Signal<boolean | undefined> => {
+    const existing = signals.get(blockId);
+    if (existing) return existing;
+    let saved: boolean | undefined;
+    try {
+      if (window.sessionStorage.getItem(storageKey(blockId)) === "open") saved = true;
+    } catch {
+      /* SSR and disabled storage keep the in-memory state. */
+    }
+    const created = createSignal(saved);
+    signals.set(blockId, created);
+    return created;
+  };
   return {
-    get: (blockId) => {
-      if (!openByBlockId.has(blockId)) {
-        try {
-          const saved = window.sessionStorage.getItem(storageKey(blockId));
-          if (saved === "open") openByBlockId.set(blockId, true);
-        } catch {
-          /* SSR and disabled storage keep the in-memory state. */
-        }
-      }
-      return openByBlockId.get(blockId);
-    },
+    get: (blockId) => signal(blockId)[0](),
     set: (blockId, open) => {
-      openByBlockId.set(blockId, open);
+      signal(blockId)[1](open);
       try {
         if (open) window.sessionStorage.setItem(storageKey(blockId), "open");
         else window.sessionStorage.removeItem(storageKey(blockId));

package/src/ai/chat/tool-groups.ts

@@ -1,10 +1,18 @@
+import { aiSkillFilePathFromMount } from "../file-mount";
 import type { AiTurnBlock } from "../protocol";
 import { aiChatMessages } from "./messages";
 
 type Tool = Extract<AiTurnBlock, { kind: "tool" }>;
 type Text = Extract<AiTurnBlock, { kind: "text" }>;
 export type AiWorkEntry = Exclude<AiTurnBlock, { kind: "text" } | { kind: "steer_message" }>;
-export type AiWorkGroup = { kind: "text"; block: Text } | { kind: "steps"; id: string; entries: AiWorkEntry[] };
+/**
+ * One row of the expanded work, all at one indent: an intermediate text, a step, or a group that folds housekeeping
+ * steps and opens in place.
+ */
+export type AiWorkItem =
+  | { kind: "text"; block: Text }
+  | { kind: "step"; entry: AiWorkEntry }
+  | { kind: "housekeeping"; id: string; entries: AiWorkEntry[] };
 
 /** A failed call, including a code run that reported an error. A rejected approval is a decision, not a failure. */
 export function isFailedTool(tool: Tool): boolean {
@@ -20,46 +28,65 @@ export function isFailedTool(tool: Tool): boolean {
   );
 }
 
+const HOUSEKEEPING_TOOLS = new Set([
+  "load_skill",
+  "search_skills",
+  "load_tools",
+  "search_tools",
+  "list_apps",
+  "search_help",
+  "read_help",
+  "search_project",
+  "read_project_knowledge",
+]);
+
+/** Preparation the reader rarely needs: loading tools, skills, and knowledge, and reading a loaded skill's files. */
+export const isHousekeepingTool = (tool: Tool): boolean => {
+  if (HOUSEKEEPING_TOOLS.has(tool.name)) return true;
+  if (tool.name !== "read_file" && tool.name !== "list_files") return false;
+  const path = tool.args !== null && typeof tool.args === "object" && "path" in tool.args ? tool.args.path : undefined;
+  return typeof path === "string" && aiSkillFilePathFromMount(path.trim()) !== null;
+};
+
+const isStep = (entry: AiWorkEntry) => entry.kind === "tool" || entry.kind === "compaction";
+
 /**
- * Split folded work into intermediate texts and the step groups between them. Reasoning stays inside its group so it
- * does not break up the tools around it. A group is keyed by its first tool, whose id is the same live and in history.
+ * The rows of the expanded work, in the original order. A run of at least two housekeeping steps, with the reasoning
+ * between them, folds into one group, unless it would hold all but one of the work's steps: then the steps show
+ * directly, so the work line never opens to a summary of itself. Entries listed in `shown` already show as rows of
+ * their own and never fold into a group, so nothing a reader sees folds away under them. A group is keyed by its first
+ * tool, whose id is the same live and in history.
  */
-export function groupWorkBlocks(blocks: readonly AiTurnBlock[]): AiWorkGroup[] {
-  const groups: AiWorkGroup[] = [];
-  for (const block of blocks) {
-    if (block.kind === "steer_message") continue;
-    if (block.kind === "text") {
-      groups.push({ kind: "text", block });
-      continue;
+export function groupWorkBlocks(blocks: readonly AiTurnBlock[], shown: ReadonlySet<string> = new Set()): AiWorkItem[] {
+  const entries = blocks.filter((block): block is AiWorkEntry | Text => block.kind !== "steer_message");
+  const steps = entries.filter((entry) => entry.kind !== "text" && isStep(entry)).length;
+  const items: AiWorkItem[] = [];
+  let run: AiWorkEntry[] = [];
+  let trailing: AiWorkEntry[] = [];
+  const flush = () => {
+    if (run.length > 0) {
+      const runSteps = run.filter(isStep).length;
+      if (runSteps >= 2 && steps - runSteps >= 2) items.push({ kind: "housekeeping", id: run[0]!.id, entries: run });
+      else for (const entry of run) items.push({ kind: "step", entry });
+    }
+    // Reasoning after the last housekeeping step belongs to what comes next.
+    for (const entry of trailing) items.push({ kind: "step", entry });
+    run = [];
+    trailing = [];
+  };
+  for (const entry of entries) {
+    const foldable = !shown.has(entry.id);
+    if (foldable && entry.kind === "tool" && isHousekeepingTool(entry)) {
+      run.push(...trailing, entry);
+      trailing = [];
+    } else if (foldable && entry.kind === "thinking" && run.length > 0) trailing.push(entry);
+    else {
+      flush();
+      items.push(entry.kind === "text" ? { kind: "text", block: entry } : { kind: "step", entry });
     }
-    const last = groups.at(-1);
-    if (last?.kind === "steps") last.entries.push(block);
-    else groups.push({ kind: "steps", id: block.id, entries: [block] });
-  }
-  for (const group of groups) {
-    if (group.kind === "steps") group.id = (group.entries.find((entry) => entry.kind === "tool") ?? group.entries[0]!).id;
   }
-  return groups;
-}
-
-/** What a group of tools did, in categories; failures and rejections are counted separately. */
-export function summarizeToolGroup(tools: readonly Tool[], locale: string): string {
-  const t = aiChatMessages(locale);
-  const categories = tools.map((tool) => {
-    if (tool.name === "todo_write") return t.groupPlan;
-    if (tool.name === "present" || tool.name === "code_present" || tool.name === "card" || tool.name === "cloud_card")
-      return t.groupDelivered;
-    if (tool.name.startsWith("code_")) return t.groupCode;
-    if (tool.presentation?.kind === "capability" || tool.name === "read_cloud_resource") return t.groupCloud;
-    if (["read_file", "list_files", "view_image"].includes(tool.name)) return t.groupReadFiles;
-    if (tool.name === "write_file") return t.groupWriteFiles;
-    if (["markdown_to_pdf", "html_to_pdf"].includes(tool.name)) return t.groupPdf;
-    if (["load_skill", "load_tools", "search_tools", "list_apps"].includes(tool.name)) return t.groupLoad;
-    if (tool.name.startsWith("web_") || tool.name === "fetch_file") return t.groupWeb;
-    if (tool.name === "memory") return t.groupMemory;
-    return t.groupTools;
-  });
-  return [...new Set(categories)].join(", ");
+  flush();
+  return items;
 }
 
 /** "9 steps · 1 failed · 1 rejected" for a group of steps. */

package/src/ai/chat/tool-names.ts

@@ -0,0 +1,157 @@
+import { i18n } from "@k2b/stdlib";
+
+/**
+ * People-facing names of Cloud's built-in Assistant tools, keyed by tool name. Step rows, receipts, and approvals show
+ * these; a capability tool brings its own translated title instead. A tool test fails when a built-in tool has no entry.
+ */
+const toolNames = i18n.define({
+  baseLocale: "en",
+  messages: {
+    en: {
+      calculate: "Calculate",
+      card: "Card",
+      survey: "Survey",
+      text_editor: "Text editor",
+      local_bash: "Local Bash",
+      todo_write: "Working plan",
+      memory: "Memory",
+      list_files: "List files",
+      read_file: "Read file",
+      write_file: "Write file",
+      fetch_file: "Download file",
+      present: "Deliver file",
+      markdown_to_pdf: "Markdown to PDF",
+      html_to_pdf: "HTML to PDF",
+      view_image: "View image",
+      transcribe_audio: "Transcribe audio",
+      web_search: "Web search",
+      web_extract: "Read web page",
+      search_tools: "Search tools",
+      load_tools: "Load tools",
+      list_apps: "List apps",
+      search_help: "Search help",
+      read_help: "Read help",
+      search_project: "Search project",
+      read_project_knowledge: "Read project knowledge",
+      read_cloud_resource: "Read Cloud item",
+      load_skill: "Load skill",
+      search_skills: "Search skills",
+      code_run: "Run code",
+      code_action: "Run app action",
+      code_inspect: "Inspect run",
+      code_stop: "Stop run",
+      code_open: "Open app",
+      code_export: "Save run output",
+      code_present: "Show app in chat",
+      code_check: "App check",
+      code_secret: "Enter secret",
+      code_database: "App tables",
+      code_files: "List stored files",
+      code_file_stat: "File details",
+      code_file_copy: "Copy file",
+      code_database_export: "Export app database",
+      code_manage_read: "Read app details",
+      code_delete: "Delete app",
+      code_database_read: "Read app database",
+      code_database_clear: "Clear app data",
+      code_database_reset: "Reset app database",
+      code_storage_list: "List app storage",
+      code_storage_delete: "Delete from app storage",
+      code_access_read: "Read app access",
+      code_access_change: "Change app access",
+      code_actions: "List app actions",
+      code_sql: "Query app database",
+      code_versions: "List app versions",
+      code_list: "Find apps",
+      code_read: "Read app source",
+      code_history: "App history",
+      code_fork: "Copy app",
+      code_publish: "Publish app",
+      code_unpublish: "Withdraw app",
+      code_restore: "Restore app version",
+      code_update: "Update app details",
+      code_create: "Create app",
+      code_write: "Save app files",
+      code_remove: "Remove app file",
+    },
+    de: {
+      calculate: "Rechnen",
+      card: "Karte",
+      survey: "Umfrage",
+      text_editor: "Texteditor",
+      local_bash: "Lokale Bash",
+      todo_write: "Arbeitsplan",
+      memory: "Gedächtnis",
+      list_files: "Dateien auflisten",
+      read_file: "Datei lesen",
+      write_file: "Datei schreiben",
+      fetch_file: "Datei herunterladen",
+      present: "Datei bereitstellen",
+      markdown_to_pdf: "Markdown als PDF",
+      html_to_pdf: "HTML als PDF",
+      view_image: "Bild ansehen",
+      transcribe_audio: "Audio transkribieren",
+      web_search: "Websuche",
+      web_extract: "Webseite lesen",
+      search_tools: "Werkzeuge suchen",
+      load_tools: "Werkzeuge laden",
+      list_apps: "Apps auflisten",
+      search_help: "Hilfe durchsuchen",
+      read_help: "Hilfe lesen",
+      search_project: "Projekt durchsuchen",
+      read_project_knowledge: "Projektwissen lesen",
+      read_cloud_resource: "Cloud-Eintrag lesen",
+      load_skill: "Skill laden",
+      search_skills: "Skills suchen",
+      code_run: "Code ausführen",
+      code_action: "App-Aktion ausführen",
+      code_inspect: "Lauf prüfen",
+      code_stop: "Lauf beenden",
+      code_open: "App öffnen",
+      code_export: "Laufergebnis speichern",
+      code_present: "App im Chat zeigen",
+      code_check: "App-Prüfung",
+      code_secret: "Geheimnis eingeben",
+      code_database: "App-Tabellen",
+      code_files: "Gespeicherte Dateien auflisten",
+      code_file_stat: "Dateidetails",
+      code_file_copy: "Datei kopieren",
+      code_database_export: "App-Datenbank exportieren",
+      code_manage_read: "App-Details lesen",
+      code_delete: "App löschen",
+      code_database_read: "App-Datenbank lesen",
+      code_database_clear: "App-Daten leeren",
+      code_database_reset: "App-Datenbank zurücksetzen",
+      code_storage_list: "App-Speicher auflisten",
+      code_storage_delete: "Aus App-Speicher löschen",
+      code_access_read: "App-Zugriff lesen",
+      code_access_change: "App-Zugriff ändern",
+      code_actions: "App-Aktionen auflisten",
+      code_sql: "App-Datenbank abfragen",
+      code_versions: "App-Versionen auflisten",
+      code_list: "Apps suchen",
+      code_read: "App-Quelltext lesen",
+      code_history: "App-Verlauf",
+      code_fork: "App kopieren",
+      code_publish: "App veröffentlichen",
+      code_unpublish: "App zurückziehen",
+      code_restore: "App-Version wiederherstellen",
+      code_update: "App-Details ändern",
+      code_create: "App erstellen",
+      code_write: "App-Dateien speichern",
+      code_remove: "App-Datei entfernen",
+    },
+  },
+});
+
+/** Older chats call the visual tools by their `cloud_` names. */
+const ALIASES: Record<string, string> = { cloud_card: "card", cloud_survey: "survey", cloud_text_editor: "text_editor" };
+
+/** The localized name of a built-in tool, or undefined for a tool Cloud does not ship. */
+export const aiBuiltinToolName = (name: string, locale: string): string | undefined => {
+  const t: Record<string, string> = toolNames.resolve([locale]).t;
+  const key = ALIASES[name] ?? name;
+  return Object.hasOwn(t, key) ? t[key] : undefined;
+};
+
+export const checkAiToolNames = () => toolNames.check();

package/src/ai/chat/turn-layout.ts

@@ -1,4 +1,5 @@
 import { type AiTurnBlock, isRenderableTurnBlock } from "../protocol";
+import type { AiStoredMessage } from "../types";
 import { hasCapabilityTable } from "./capability-result";
 import { isCardToolName, isRecord, isSurveyToolName, isTextEditorToolName } from "./message-utils";
 import { isFailedTool } from "./tool-groups";
@@ -78,9 +79,9 @@ const actionState = (block: ToolBlock, phase: AiTurnPhase): AiTurnActionState |
   if (block.status === "rejected") return "rejected";
   if (isSurveyToolName(block.name) || isTextEditorToolName(block.name)) return isFailedTool(block) ? null : "interaction";
   if (block.name === "code_secret") return block.status === "awaiting_client" ? "interaction" : null;
-  // Effects in Cloud and decided approvals stay visible as receipts, whether or not the model mentions them.
+  // Effects in Cloud and approvals, decided or expired, stay visible as receipts, whether or not the model mentions them.
   const capabilityAction = block.presentation?.kind === "capability" && block.presentation.capabilityKind === "action";
-  if (!capabilityAction && !block.approved) return null;
+  if (!capabilityAction && block.approved === undefined) return null;
   if (block.status === "running" || block.status === "awaiting_client") return live(phase) ? "running" : "not_run";
   return isFailedTool(block) ? "failed" : "done";
 };
@@ -139,3 +140,14 @@ export function layoutAiTurn(input: readonly AiTurnBlock[], options: { phase: Ai
     waitingFor,
   };
 }
+
+/** The loop ending is authoritative; partial messages also carry their own failed or interrupted ending. */
+export const storedPhase = (entries: readonly Pick<AiStoredMessage, "loopDoneReason" | "stopReason">[]): AiTurnPhase => {
+  const reason = entries.findLast((entry) => entry.loopDoneReason)?.loopDoneReason;
+  if (reason === "aborted") return "stopped";
+  if (reason && reason !== "stop") return "failed";
+  const stop = entries.findLast((entry) => entry.stopReason)?.stopReason;
+  if (stop === "error") return "failed";
+  if (stop === "interrupted" || stop === "aborted") return "stopped";
+  return "completed";
+};