@k2b/cloud 0.38.0 → 0.40.0

package/src/ai/chat/action-sentences.ts

@@ -1,15 +1,4 @@
 import { createContext, useContext } from "solid-js";
-import {
-  type CapabilityActionWording,
-  capabilityActionOutcome,
-  capabilityActionSubject,
-  resolveCapabilityActionSentences,
-} from "../../_internal/capability-sentences";
-import type { AiTurnBlock } from "../protocol";
-import { CLOUD_AI_TOOL_PRESENTATION } from "../tool-sentences";
-import { displayToolName, isRecord } from "./message-utils";
-
-type ToolBlock = Extract<AiTurnBlock, { kind: "tool" }>;
 
 const ReaderTimeZoneContext = createContext<string>();
 
@@ -20,36 +9,4 @@ export const AiReaderTimeZoneProvider = ReaderTimeZoneContext.Provider;
 export const useReaderTimeZone = (): string =>
   useContext(ReaderTimeZoneContext) ?? (typeof window === "undefined" ? "UTC" : Intl.DateTimeFormat().resolvedOptions().timeZone);
 
-/**
- * How the chat words one call that acts on something: an app Action through its saved presentation, a
- * Cloud tool through Cloud's own catalog of the same shape. `null` for calls that only read.
- */
-export const toolWording = (block: ToolBlock, locale: string): CapabilityActionWording | null => {
-  const presentation = block.presentation;
-  if (presentation?.kind === "capability") {
-    if (presentation.capabilityKind !== "action") return null;
-    return {
-      title: presentation.title,
-      ...(presentation.sentences ? { sentences: presentation.sentences } : {}),
-      ...(presentation.fields ? { fields: presentation.fields } : {}),
-    };
-  }
-  const sentences = resolveCapabilityActionSentences(block.name, CLOUD_AI_TOOL_PRESENTATION, locale);
-  return sentences ? { title: displayToolName(block.name, locale), sentences } : null;
-};
-
-/** What the call does or would do, as one sentence; `null` for calls that only read. */
-export const toolSubject = (block: ToolBlock, locale: string, timeZone: string): string | null => {
-  const wording = toolWording(block, locale);
-  return wording ? capabilityActionSubject(wording, block.args, { locale, timeZone }) : null;
-};
-
-/** The sentence for one outcome, or `null` when the tool has none that renders for this call. */
-export const toolOutcome = (block: ToolBlock, key: "done" | "rejected" | "notRun", locale: string, timeZone: string): string | null => {
-  const wording = toolWording(block, locale);
-  if (!wording) return null;
-  const result = isRecord(block.result) ? block.result : undefined;
-  // App Actions return their data inside the result envelope; Cloud tools return the data itself.
-  const data = block.presentation?.kind === "capability" ? result?.data : block.result;
-  return capabilityActionOutcome(wording, key, { input: block.args, data }, { locale, timeZone });
-};
+export { toolOutcome, toolSubject, toolWording } from "../tool-wording";

package/src/ai/chat/blocks.tsx

@@ -3,6 +3,7 @@ import { mutation } from "@k2b/stdlib/solid";
 import { Button, ButtonLink, Chat, isStructuredDataValue, MarkdownView, SplitButton, StructuredDataPreview, useLocale } from "@k2b/ui";
 import { createSignal, createUniqueId, For, type JSX, Match, Show, Switch, untrack } from "solid-js";
 import { capabilityApprovalReason, capabilityApprovalReasonLabel } from "../../_internal/capability-sentences";
+import { capabilityReviewView } from "../../capabilities/reviews";
 import type { CapabilityActionReview } from "../../contracts/capabilities";
 import { markdown } from "../../shared";
 import type { AiTurnBlock } from "../protocol";
@@ -31,8 +32,10 @@ import {
 } from "./message-utils";
 import { aiChatMessages } from "./messages";
 import { AssistantMarkdownBlock } from "./primitives";
+import { ToolActionView } from "./tool-action";
 import { AiToolActivity } from "./tool-disclosure";
 import { isFailedTool } from "./tool-groups";
+import type { AiTurnActionState } from "./turn-layout";
 import { CloudCardBlock, CloudSurveyBlock, CloudSurveyResultBlock, CloudTextEditorBlock, CloudTextEditorResultBlock } from "./visual-tools";
 import { FetchFileToolBlock, WebExtractToolBlock, WebSearchToolBlock, WebsiteReceipts, websiteReceipts } from "./web-tools";
 
@@ -199,6 +202,7 @@ export function ApprovalBlockView(props: { turnId: string; block: ToolBlock; onD
   const locale = useLocale();
   const timeZone = useReaderTimeZone();
   const t = () => aiChatMessages(locale());
+  const review = () => (props.block.approval?.review ? capabilityReviewView(props.block.approval.review, { timeZone }) : undefined);
   const request = () => ({ turnId: props.turnId, callId: props.block.callId, name: props.block.name });
   const pending = () => props.block.status === "awaiting_approval";
   const actionDisabled = () => actions.actionDisabled?.() ?? false;
@@ -229,7 +233,7 @@ export function ApprovalBlockView(props: { turnId: string; block: ToolBlock; onD
   // The model's own reason, labelled as such, only where Cloud offered it; it adds to the app's sentence and never replaces it.
   const reason = () => (props.block.presentation?.approvalReason ? capabilityApprovalReason(props.block.args) : null);
   const description = () => {
-    const reviewMessage = props.block.approval?.review?.message.trim();
+    const reviewMessage = review()?.message.trim();
     if (reviewMessage) return reviewMessage;
     // An app Action's approval text repeats its heading and reason for text-only readers; the card shows them itself.
     if (capability()) return null;
@@ -252,10 +256,9 @@ export function ApprovalBlockView(props: { turnId: string; block: ToolBlock; onD
         const match = /^([^:]{1,40}):\s+(.+)$/.exec(line);
         return match ? { label: match[1], value: match[2] } : { value: line };
       });
-  const inlineReviewDetails = () =>
-    (props.block.approval?.review?.details ?? []).filter((detail) => (detail.display ?? "inline") === "inline");
-  const blockReviewDetails = () => (props.block.approval?.review?.details ?? []).filter((detail) => detail.display === "block");
-  const reviewLinks = () => props.block.approval?.review?.links ?? [];
+  const inlineReviewDetails = () => (review()?.details ?? []).filter((detail) => (detail.display ?? "inline") === "inline");
+  const blockReviewDetails = () => (review()?.details ?? []).filter((detail) => detail.display === "block");
+  const reviewLinks = () => review()?.links ?? [];
   const reviewLinkTitle = (rel: "open" | "edit" | "status" | "preview" | "download") =>
     ({
       open: t().openIn({ app: ownerName() }),
@@ -545,20 +548,6 @@ function CapabilityToolView(props: { block: ToolBlock }) {
   );
 }
 
-function RejectedToolView(props: { block: ToolBlock }) {
-  const locale = useLocale();
-  const timeZone = useReaderTimeZone();
-  const presentation = () => props.block.presentation;
-  const title = () => toolSubject(props.block, locale(), timeZone) ?? presentation()?.title ?? displayToolName(props.block.name, locale());
-  return (
-    <Chat.Activity
-      icon={aiToolIcon(props.block.name, presentation()?.appIcon)}
-      label={toolOutcome(props.block, "rejected", locale(), timeZone) ?? aiChatMessages(locale()).toolRejected({ title: title() })}
-      accent={presentation()?.appAccent}
-    />
-  );
-}
-
 export function SurveyToolView(props: { turnId: string; block: ToolBlock; active?: boolean }) {
   const actions = useAiChatActions();
   const locale = useLocale();
@@ -670,6 +659,15 @@ function ToolBlockView(props: { turnId: string; block: ToolBlock; active?: boole
   const actions = useAiChatActions();
   const locale = useLocale();
   const status = () => props.block.status;
+  // The same states as place 4 of a turn: open, then running, done, rejected, failed, or not run.
+  const actionState = (): AiTurnActionState | "open" | undefined => {
+    if (status() === "awaiting_approval") return "open";
+    if (status() === "rejected") return "rejected";
+    const action = props.block.presentation?.kind === "capability" && props.block.presentation.capabilityKind === "action";
+    if (!action) return undefined;
+    if (status() === "running" || status() === "awaiting_client") return props.active === false ? "not_run" : "running";
+    return isFailedTool(props.block) ? "failed" : "done";
+  };
   const fetchError = () =>
     props.block.name === "fetch_file" && props.block.isError ? fetchFileErrorPresentation(props.block.result, locale()) : undefined;
   return (
@@ -688,12 +686,8 @@ function ToolBlockView(props: { turnId: string; block: ToolBlock; active?: boole
           />
         }
       >
-        <Match when={status() === "awaiting_approval"}>
-          <ApprovalBlockView turnId={props.turnId} block={props.block} />
-        </Match>
-        <Match when={status() === "rejected"}>
-          <RejectedToolView block={props.block} />
-        </Match>
+        {/* A question, and every outcome of an app Action, is one card v4 element. */}
+        <Match when={actionState()}>{(state) => <ToolActionView block={props.block} turnId={props.turnId} state={state()} />}</Match>
         <Match when={props.block.presentation?.kind === "capability"}>
           <CapabilityToolView block={props.block} />
         </Match>

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

@@ -12,6 +12,7 @@ import {
 } from "@k2b/ui";
 import { createContext, createSignal, For, type JSX, Show, useContext } from "solid-js";
 import type { CloudResourceRef } from "../../contracts/capabilities";
+import type { AiActionCheck } from "../action-review";
 import type { AiTurnBlock } from "../protocol";
 import type { AiMessageFeedback, AiMessageFeedbackReason, AiStoredMessage } from "../types";
 import {
@@ -46,6 +47,11 @@ export type AiChatActions = {
   /** Revoke the approval that lets this chat read `origin` without asking; the next request asks again. */
   onRevokeWebsite?: (origin: string) => Promise<void>;
   onFrontendToolResult?: FrontendToolResultHandler;
+  /**
+   * Ask the owning app once more whether a call whose outcome stayed unknown happened, through its `check` Query. Never
+   * repeats the call itself. Resolves with the stored check; without it, an unknown outcome offers no new check.
+   */
+  onCheckAction?: (request: AiTurnActionRequest) => Promise<AiActionCheck>;
   onForkMessage?: ForkMessageHandler;
   onRetryMessage?: RetryMessageHandler;
   onRetrySteer?: RetrySteerHandler;

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

@@ -0,0 +1,481 @@
+import { dates } from "@k2b/stdlib";
+import { Button, ButtonLink, type ChatDecisionState, useLocale } from "@k2b/ui";
+import { createEffect, createMemo, createSignal, For, type JSX, on, onCleanup, Show } from "solid-js";
+import { capabilityUnknownText } from "../../_internal/capability-sentences";
+import { CapabilityActionReceiptSchema } from "../../contracts/capabilities";
+import { AI_TOOL_CHECK_STALE_MS, type AiActionCheck } from "../action-review";
+import type { AiTurnBlock } from "../protocol";
+import { toolOutcome } from "../tool-wording";
+import { type ActionCard, type ActionText, actionReceiptText, toolActionCard } from "./action-card";
+import { actionMessages } from "./action-messages";
+import { type ActionLine, ActionQuestion, ActionReceipt } from "./action-question";
+import { useReaderTimeZone } from "./action-sentences";
+import { useAiChatActions } from "./message-actions";
+import { capabilityErrorDescription, isRecord } from "./message-utils";
+import { aiChatMessages } from "./messages";
+import type { AiTurnActionState, AiTurnPhase } from "./turn-layout";
+
+type ToolBlock = Extract<AiTurnBlock, { kind: "tool" }>;
+
+/**
+ * Codes that say Cloud could not see whether the Action happened; nothing may repeat it blindly. Core rewrites a
+ * failure after it reached the app to ACTION_OUTCOME_UNKNOWN, so a bare transport code such as APP_UNAVAILABLE failed
+ * before the app saw anything, or comes from older history; either way it reads as a failure with its message.
+ */
+const UNKNOWN_CODES = new Set(["ACTION_OUTCOME_UNKNOWN", "IDEMPOTENCY_UNCERTAIN", "IDEMPOTENCY_IN_PROGRESS"]);
+
+/** Cloud's own transport codes: they say the call failed, not that the app refused it, so they never claim "not run". */
+const TRANSPORT_CODES = new Set([
+  "DEADLINE_EXCEEDED",
+  "APP_UNAVAILABLE",
+  "REQUEST_CANCELLED",
+  "INVALID_APP_RESPONSE",
+  "RESPONSE_TOO_LARGE",
+  "INTERNAL",
+]);
+
+/** The framework code of a failed call, from `CODE: message` or a structured error. */
+export const toolErrorCode = (result: unknown): string | null => {
+  if (typeof result === "string") return /^([A-Z][A-Z0-9_]{2,}):/.exec(result.trim())?.[1] ?? null;
+  if (isRecord(result) && typeof result.code === "string") return result.code;
+  return null;
+};
+
+/** The message without its code, so the detail under a line reads as a sentence. */
+const errorDetail = (result: unknown): string => capabilityErrorDescription(result).replace(/^[A-Z][A-Z0-9_]{2,}:\s*/, "");
+
+/** The application's own short summary of a result, if it fits on one line. */
+const resultSummary = (block: ToolBlock): string | undefined => {
+  const value = isRecord(block.result) ? block.result.summary : undefined;
+  return typeof value === "string" && value.trim() && value.trim().length <= 500 ? value.trim() : undefined;
+};
+
+/** The words of a call without an app sentence: Cloud's frames around its catalog sentence or title. */
+export const legacyOutcomeWords = (block: ToolBlock, locale: string, timeZone: string) => (subject: string) => {
+  const t = aiChatMessages(locale);
+  const capability = block.presentation?.kind === "capability";
+  return {
+    running: t.receiptRunning({ title: subject }),
+    // The app's done sentence, else its own summary of the call, else Cloud's frame.
+    done:
+      toolOutcome(block, "done", locale, timeZone) ??
+      resultSummary(block) ??
+      (capability ? t.receiptDone({ title: subject }) : t.receiptApproved({ title: subject })),
+    rejected: toolOutcome(block, "rejected", locale, timeZone) ?? t.receiptRejected({ title: subject }),
+    notRun: toolOutcome(block, "notRun", locale, timeZone) ?? t.receiptNotRun({ title: subject, stopped: false }),
+    unknown: capabilityUnknownText(subject, locale),
+    unknownStill: capabilityUnknownText(subject, locale, true),
+  };
+};
+
+/** The card of one tool block in the reader's locale and zone. */
+export const useToolActionCard = (block: () => ToolBlock): (() => ActionCard) => {
+  const locale = useLocale();
+  const timeZone = useReaderTimeZone();
+  return createMemo(() =>
+    toolActionCard(block(), { locale: locale(), timeZone, outcome: legacyOutcomeWords(block(), locale(), timeZone) }),
+  );
+};
+
+type LocalAnswer = "approve" | "decline" | null;
+
+/** Which outcome a call reached and what the person did here, as one key per flow. */
+type Flow =
+  | { flow: "run"; current: "running" | "done" }
+  | { flow: "rejected" }
+  | { flow: "expired" }
+  | { flow: "stopped" }
+  | { flow: "error" }
+  | { flow: "failed" }
+  | { flow: "lost" }
+  | {
+      flow: "check";
+      current: "checking" | "checkedDone" | "checkedNotDone" | "pending" | "checkFailed" | "noCheck" | "cutOff";
+    };
+
+const flowOf = (input: {
+  block: ToolBlock;
+  state: AiTurnActionState | "open";
+  answer: LocalAnswer;
+  lost: boolean;
+  check: AiActionCheck | undefined;
+  phase?: AiTurnPhase;
+  /** The stored claim of a running check is older than the stale limit. */
+  staleCheck?: boolean;
+}): Flow => {
+  const { block, check } = input;
+  // A lost answer holds only while the question still waits; the server's own outcome always wins over it.
+  if (input.lost && block.status === "awaiting_approval") return { flow: "lost" };
+  if (block.status === "awaiting_approval") return input.answer === "decline" ? { flow: "rejected" } : { flow: "run", current: "running" };
+  // A check runs only inside a live turn and only for a while; one that history still shows as running, or whose
+  // claim went stale, was cut off and is open again.
+  if (check?.state === "checking")
+    return input.staleCheck || input.phase === "completed" || input.phase === "stopped" || input.phase === "failed"
+      ? { flow: "check", current: "pending" }
+      : { flow: "check", current: "checking" };
+  if (check?.state === "done") return { flow: "check", current: "checkedDone" };
+  if (check?.state === "not_done") return { flow: "check", current: "checkedNotDone" };
+  // An open check stays open whatever the call's own end looked like, such as a turn stopped while it checked.
+  if (check?.state === "pending") return { flow: "check", current: "pending" };
+  if (check?.state === "failed") return { flow: "check", current: "checkFailed" };
+  if (input.state === "rejected") return { flow: "rejected" };
+  // The person's stop ends an open question or a call it cut off; a question nobody answered expired. A call that was
+  // still running when the turn ended any other way may have reached the app, so its outcome is open.
+  if (input.state === "not_run") {
+    if (input.phase === "stopped") return { flow: "stopped" };
+    return block.approved === false ? { flow: "expired" } : { flow: "check", current: "cutOff" };
+  }
+  if (input.state === "failed") {
+    const code = toolErrorCode(block.result);
+    if (code === "ACTION_NOT_DONE") return { flow: "check", current: "checkedNotDone" };
+    if (code && UNKNOWN_CODES.has(code)) {
+      return { flow: "check", current: "noCheck" };
+    }
+    // A failure with an app's code was refused before anything happened; a transport code or none proves nothing.
+    return code && !TRANSPORT_CODES.has(code) ? { flow: "error" } : { flow: "failed" };
+  }
+  if (input.state === "done") return { flow: "run", current: "done" };
+  return { flow: "run", current: "running" };
+};
+
+/**
+ * One call in place 4: the open question, then, in the same element, its outcome line. An answer here collapses the
+ * question at once to the running or declined line and moves the focus there; the server's outcome replaces it in the
+ * same cell. A call that never asked shows only its outcome line.
+ */
+export function ToolActionView(props: {
+  block: ToolBlock;
+  turnId: string;
+  /** The block's place-4 state from the turn layout; `open` while it waits for this person. */
+  state: AiTurnActionState | "open";
+  phase?: AiTurnPhase;
+}) {
+  const actions = useAiChatActions();
+  const timeZone = useReaderTimeZone();
+  const card = useToolActionCard(() => props.block);
+  const t = () => actionMessages(card().locale);
+  const [answer, setAnswer] = createSignal<LocalAnswer>(null);
+  const [lost, setLost] = createSignal(false);
+  const [elsewhere, setElsewhere] = createSignal(false);
+  const [checked, setChecked] = createSignal<AiActionCheck | null>(null);
+  const [checking, setChecking] = createSignal(false);
+  const [checkError, setCheckError] = createSignal(false);
+  // A new approval for the same block, such as the next website a code run asks for, starts a fresh question. `on`
+  // runs again whenever the block changes, so the call id is compared by hand.
+  let answeredCall = props.block.callId;
+  createEffect(
+    on(
+      () => props.block.callId,
+      (callId) => {
+        if (callId === answeredCall) return;
+        answeredCall = callId;
+        // Only a new question starts fresh; the block returning to its parent call after this answer keeps it.
+        if (props.block.status !== "awaiting_approval") return;
+        setAnswer(null);
+        setLost(false);
+        setElsewhere(false);
+      },
+    ),
+  );
+  // A question that leaves this window open without an answer here was decided somewhere else. (`on` with `defer`
+  // never passes the first value as the previous one, so this effect runs from the start.)
+  createEffect(
+    on(
+      () => props.block.status === "awaiting_approval",
+      (open, wasOpen) => {
+        if (wasOpen === true && !open && answer() === null) setElsewhere(true);
+        if (!open) setLost(false);
+      },
+    ),
+  );
+  const request = () => ({ turnId: props.turnId, callId: props.block.callId, name: props.block.name });
+  const submit = async (input: { approved: boolean; remember?: "chat" }) => {
+    if (answer() !== null || !actions.onApproval) return;
+    // A failure belongs to the question it answered: the next question of the same block may already show.
+    const submitted = props.block.callId;
+    setLost(false);
+    setAnswer(input.approved ? "approve" : "decline");
+    try {
+      await actions.onApproval(request(), input);
+    } catch {
+      if (props.block.callId === submitted) setLost(true);
+    }
+  };
+  const reopen = () => {
+    setLost(false);
+    setAnswer(null);
+  };
+  // The stored check wins once it is settled or newer than the one this card asked for, so another window's check
+  // or a reload is never hidden behind an older local answer.
+  const check = () => {
+    const local = checked();
+    const stored = props.block.check;
+    if (!local || !stored) return local ?? stored;
+    if (stored.state === "done" || stored.state === "not_done") return stored;
+    return (stored.at ?? "") > (local.at ?? "") ? stored : local;
+  };
+  // A stored claim of a running check expires at a known moment; past it the card offers to check again. The clock is
+  // read again whenever the claim changes, so a claim that arrives late expires on time too.
+  const [now, setNow] = createSignal(Date.now());
+  const claimAt = () => (check()?.state === "checking" ? check()?.at : undefined);
+  createEffect(
+    on(claimAt, (at) => {
+      setNow(Date.now());
+      if (!at) return;
+      const remaining = Date.parse(at) + AI_TOOL_CHECK_STALE_MS - Date.now();
+      if (remaining <= 0) return;
+      const timer = setTimeout(() => setNow(Date.now()), remaining + 50);
+      onCleanup(() => clearTimeout(timer));
+    }),
+  );
+  const claimAge = () => {
+    const at = claimAt();
+    return at ? now() - Date.parse(at) : null;
+  };
+  const flow = createMemo(() =>
+    flowOf({
+      block: props.block,
+      state: props.state,
+      answer: answer(),
+      lost: lost(),
+      check: check(),
+      phase: props.phase,
+      staleCheck: (claimAge() ?? 0) > AI_TOOL_CHECK_STALE_MS,
+    }),
+  );
+  const decisionState = (): ChatDecisionState => {
+    if (props.block.status === "awaiting_approval") return answer() === null && !lost() ? "open" : "sending";
+    return flow().flow === "expired" ? "expired" : "decided";
+  };
+  const time = () => (props.block.at ? dates.formatTime(props.block.at, { locale: card().locale, timeZone }) : undefined);
+  // A line that waits hidden in the cell reserves room for the time it will show, so it cannot wrap later. The widest
+  // time of the day stands in until the real one is known.
+  const reservedTime = () => time() ?? dates.formatTime("2000-01-01T23:58:00.000Z", { locale: card().locale, timeZone: "UTC" });
+  const receiptText = (): ActionText => {
+    const result = isRecord(props.block.result) ? props.block.result : null;
+    const receipt = CapabilityActionReceiptSchema.safeParse(result?.receipt);
+    return receipt.success ? actionReceiptText(receipt.data, card(), timeZone) : card().forms.done;
+  };
+  const checkAgain = async () => {
+    if (!actions.onCheckAction || checking()) return;
+    setChecking(true);
+    setCheckError(false);
+    try {
+      setChecked(await actions.onCheckAction(request()));
+    } catch {
+      setCheckError(true);
+    } finally {
+      setChecking(false);
+    }
+  };
+  const unknownActions = (withCheck: boolean): JSX.Element => (
+    <>
+      <Show when={card().open}>
+        {(href) => (
+          <ButtonLink href={href()} size="sm" variant="subtle">
+            <i class={card().app.icon} aria-hidden="true" />
+            {t().openIn({ app: card().app.name })}
+          </ButtonLink>
+        )}
+      </Show>
+      <Show when={withCheck && card().hasCheck && actions.onCheckAction}>
+        <Button size="sm" variant="subtle" loading={checking()} onClick={() => void checkAgain()}>
+          <i class="ti ti-refresh" aria-hidden="true" />
+          {t().checkAgain}
+        </Button>
+      </Show>
+    </>
+  );
+  const askAgain = () =>
+    actions.onContinueTurn
+      ? { label: t().askAgain, onSelect: () => actions.onContinueTurn?.(t().askAgainMessage({ sentence: card().short })) }
+      : undefined;
+  const lines = createMemo((): Record<string, ActionLine> => {
+    const current = flow();
+    const c = card();
+    const words = t();
+    switch (current.flow) {
+      case "run":
+        return {
+          running: { tone: "running", text: c.forms.running },
+          done: {
+            tone: "done",
+            text: receiptText(),
+            time: current.current === "done" ? time() : reservedTime(),
+            ...(elsewhere() ? { detail: words.approvedElsewhere } : {}),
+            ...(resultLinks(props.block).length > 0 ? { actions: <ResultLinks links={resultLinks(props.block)} align="start" /> } : {}),
+          },
+        };
+      case "rejected": {
+        const rejected: ActionLine = {
+          tone: "off",
+          text: c.forms.rejected,
+          detail: elsewhere() ? words.declinedElsewhere : words.declined,
+          time: time(),
+        };
+        // The time arrives with the server's answer; a hidden twin with room for it keeps the line from growing then.
+        return time() ? { rejected } : { rejected, rejectedTimed: { ...rejected, time: reservedTime() } };
+      }
+      case "expired":
+        return { expired: { tone: "off", icon: "ti ti-clock-x", text: c.forms.notRun, detail: words.expired, action: askAgain() } };
+      case "stopped":
+        return { stopped: { tone: "off", text: c.forms.notRun, detail: words.stopped } };
+      case "error":
+        return {
+          error: {
+            tone: "error",
+            text: c.forms.notRun,
+            detail: errorDetail(props.block.result) || aiChatMessages(c.locale).actionNotCompleted,
+            time: time(),
+          },
+        };
+      case "failed":
+        return {
+          failed: {
+            tone: "error",
+            text: [{ kind: "text", text: aiChatMessages(c.locale).receiptFailed({ title: c.short }) }],
+            detail: errorDetail(props.block.result) || aiChatMessages(c.locale).actionNotCompleted,
+            time: time(),
+          },
+        };
+      case "lost":
+        return {
+          lost: {
+            tone: "warning",
+            icon: "ti ti-alert-triangle",
+            text: [...splitFrame(words.lostAbout({ subject: "\u0000" }), c.subject)],
+            detail: words.lostDetail,
+            action: { label: words.answerAgain, onSelect: reopen },
+          },
+        };
+      case "check": {
+        const app = c.app.name;
+        const settled = check()?.receipt ? actionReceiptText(check()!.receipt!, c, timeZone) : c.forms.done;
+        const failedDetail = checkError() ? words.checkAgainFailed : undefined;
+        // Only the lines this check can still reach share the cell: a settled outcome stands alone, an open one keeps
+        // the room the next check needs.
+        const all: Record<string, ActionLine> = {
+          checking: { tone: "running", text: c.forms.unknown, detail: words.checking({ app }) },
+          checkedDone: { tone: "done", text: settled, detail: words.checkedDone({ app }), time: time() },
+          checkedNotDone: { tone: "off", text: c.forms.notRun, detail: words.checkedNotDone({ app }), time: time() },
+          pending: {
+            tone: "warning",
+            icon: "ti ti-help-circle",
+            text: c.forms.unknown,
+            detail: failedDetail ?? words.checkPending({ app }),
+            actions: unknownActions(true),
+          },
+          checkFailed: {
+            tone: "warning",
+            icon: "ti ti-help-circle",
+            text: c.forms.unknownStill,
+            detail: failedDetail ?? words.checkFailed({ app }),
+            actions: unknownActions(true),
+          },
+          // No check ran, such as when Core could not store its claim; the review's check, if any, is the person's.
+          noCheck: {
+            tone: "warning",
+            icon: "ti ti-help-circle",
+            text: c.forms.unknown,
+            detail: failedDetail ?? words.noCheck,
+            ...(c.open || c.hasCheck ? { actions: unknownActions(true) } : {}),
+          },
+          // A call the turn's end cut off has no check yet; the review's check, if any, is the person's to start.
+          cutOff: {
+            tone: "warning",
+            icon: "ti ti-help-circle",
+            text: c.forms.unknown,
+            detail: failedDetail ?? words.cutOff,
+            ...(c.open || c.hasCheck ? { actions: unknownActions(true) } : {}),
+          },
+        };
+        const reachable: Record<typeof current.current, (keyof typeof all)[]> = {
+          checking: ["checking", "checkedDone", "checkedNotDone", "pending", "checkFailed"],
+          pending: ["pending", "checkFailed", "checkedDone", "checkedNotDone"],
+          checkFailed: ["pending", "checkFailed", "checkedDone", "checkedNotDone"],
+          checkedDone: ["checkedDone"],
+          checkedNotDone: ["checkedNotDone"],
+          noCheck: ["noCheck", "checkedDone", "checkedNotDone", "pending", "checkFailed"],
+          cutOff: ["cutOff", "checkedDone", "checkedNotDone", "pending", "checkFailed"],
+        };
+        return Object.fromEntries(reachable[current.current].map((key) => [key, all[key]!]));
+      }
+    }
+  });
+  const currentKey = () => {
+    const current = flow();
+    return "current" in current ? current.current : current.flow;
+  };
+  const unavailable = () => {
+    if (!actions.onApproval) return actionMessages(card().locale).unavailable;
+    if (actions.actionDisabled?.()) return actionMessages(card().locale).stopping;
+    return undefined;
+  };
+  const remember = () => {
+    const approval = props.block.approval;
+    if (!approval?.allowChat) return undefined;
+    return {
+      label: approval.website ? t().rememberWebsite : t().remember,
+      onSelect: () => submit({ approved: true, remember: "chat" }),
+    };
+  };
+  return (
+    <ActionQuestion
+      card={card()}
+      state={decisionState()}
+      timeZone={timeZone}
+      anchorId={props.block.id}
+      unavailable={unavailable()}
+      remember={remember()}
+      onConfirm={() => submit({ approved: true })}
+      onDecline={() => submit({ approved: false })}
+      outcome={<ActionReceipt card={card()} lines={lines()} current={currentKey()} />}
+    />
+  );
+}
+
+/** Links a result offers, limited to paths inside this Cloud. */
+export const resultLinks = (block: ToolBlock): Record<string, unknown>[] => {
+  const value = (isRecord(block.result) ? block.result : null)?.links;
+  return Array.isArray(value)
+    ? value.filter(
+        (link): link is Record<string, unknown> =>
+          isRecord(link) && typeof link.href === "string" && /^\/(?![\\/])[^\\\u0000-\u001f\u007f]*$/.test(link.href),
+      )
+    : [];
+};
+
+export function ResultLinks(props: { links: Record<string, unknown>[]; align?: "start" | "end" }) {
+  const locale = useLocale();
+  const t = () => aiChatMessages(locale());
+  const label = (link: Record<string, unknown>) =>
+    typeof link.title === "string" ? link.title : link.rel === "edit" ? t().edit : link.rel === "download" ? t().download : t().open;
+  return (
+    <span class={`flex min-w-0 flex-wrap items-center gap-1 ${props.align === "start" ? "justify-start" : "justify-end"}`}>
+      <For each={props.links}>
+        {(link) => (
+          <ButtonLink
+            class="ai-chat-result-link"
+            href={String(link.href)}
+            target="_blank"
+            rel="noopener noreferrer"
+            size="xs"
+            variant="ghost"
+          >
+            {label(link)}
+          </ButtonLink>
+        )}
+      </For>
+    </span>
+  );
+}
+
+/** Puts a sentence into a frame such as "Your answer about \u0000 didn't arrive." */
+const splitFrame = (frame: string, inner: ActionText): ActionText => {
+  const [before = "", after = ""] = frame.split("\u0000");
+  return [
+    ...(before ? [{ kind: "text" as const, text: before }] : []),
+    ...inner,
+    ...(after ? [{ kind: "text" as const, text: after }] : []),
+  ];
+};