@k2b/cloud 0.29.0 → 0.29.1

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/turn-layout.ts

@@ -79,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";
 };

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

@@ -17,7 +17,14 @@ import {
 import { markdown } from "../../shared";
 import { AI_TURN_LEASE_MS, type AiTurnBlock } from "../protocol";
 import type { AiTurnError } from "../types";
-import { ApprovalBlockView, CompactionBlockView, CompactToolRow, SurveyToolView, TextEditorToolView } from "./blocks";
+import {
+  type AiApprovalDecision,
+  ApprovalBlockView,
+  CompactionBlockView,
+  CompactToolRow,
+  SurveyToolView,
+  TextEditorToolView,
+} from "./blocks";
 import { CapabilityTablePreview } from "./capability-table";
 import { PresentToolBlock } from "./file-tools";
 import { useAiChatActions } from "./message-actions";
@@ -25,9 +32,9 @@ import { aiToolIcon, capabilityErrorDescription, displayToolName, isCardToolName
 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 { type AiWorkEntry, type AiWorkItem, countWorkSteps, groupWorkBlocks } from "./tool-groups";
 import { aiTurnErrorCanContinue, aiTurnErrorDescription } from "./turn-error";
-import type { AiTurnAction, AiTurnLayout, AiTurnPhase, AiTurnResult } from "./turn-layout";
+import type { AiTurnAction, AiTurnActionState, AiTurnLayout, AiTurnPhase, AiTurnResult } from "./turn-layout";
 import { CloudCardBlock } from "./visual-tools";
 
 type ToolBlock = Extract<AiTurnBlock, { kind: "tool" }>;
@@ -88,10 +95,12 @@ export const formatWorkClock = (ms: number): string => {
 
 const basename = (value: string) => value.slice(value.lastIndexOf("/") + 1) || value;
 
+/** What a call acts on: the file name of its path, or its name, title, or query as given. */
 const toolTarget = (block: ToolBlock): string => {
   const args = isRecord(block.args) ? block.args : {};
-  const value = [args.path, args.name, args.title, args.query].find((entry) => typeof entry === "string" && entry.trim());
-  return typeof value === "string" ? basename(value.trim()) : "";
+  if (typeof args.path === "string" && args.path.trim()) return basename(args.path.trim());
+  const value = [args.name, args.title, args.query].find((entry) => typeof entry === "string" && entry.trim());
+  return typeof value === "string" ? value.trim() : "";
 };
 
 /** A step that runs longer than this shows its duration, so a long step does not look like a stalled one. */
@@ -234,6 +243,7 @@ function ThoughtRow(props: { block: Extract<AiTurnBlock, { kind: "thinking" }>;
         blockId={props.block.id}
         label={firstLine()}
         icon="ti ti-bulb"
+        bodyInset={false}
         renderBody={() => <p class="ai-turn-steps__thought">{props.block.text.trim()}</p>}
       />
     </Show>
@@ -254,25 +264,26 @@ function WorkEntryRow(props: { entry: AiWorkEntry; busy: boolean }) {
   );
 }
 
-function WorkGroup(props: { id: string; entries: AiWorkEntry[]; active: boolean }) {
+/** Housekeeping folded into one row at step level. It opens in place: its steps follow at the same indent. */
+function HousekeepingGroup(props: { id: string; entries: AiWorkEntry[]; active: boolean }) {
   const locale = useLocale();
-  const tools = () => props.entries.filter((entry): entry is ToolBlock => entry.kind === "tool");
   const last = () => props.entries.at(-1)!;
   return (
-    <Show when={props.entries.length > 1} fallback={<WorkEntryRow entry={last()} busy={props.active} />}>
-      <AiToolActivity
-        blockId={`group:${props.id}`}
-        label={tools().length ? summarizeToolGroup(tools(), locale()) : aiChatMessages(locale()).reasoning}
-        description={countWorkSteps(props.entries, locale())}
-        icon="ti ti-stack-2"
-        busy={props.active && last().kind === "tool" && (last() as ToolBlock).status === "running"}
-        renderBody={() => (
+    <AiToolActivity
+      blockId={`group:${props.id}`}
+      label={aiChatMessages(locale()).groupLoad}
+      description={countWorkSteps(props.entries, locale())}
+      icon="ti ti-stack-2"
+      bodyInset={false}
+      busy={props.active && last().kind === "tool" && (last() as ToolBlock).status === "running"}
+      renderBody={() => (
+        <div class="ai-turn-steps">
           <For each={props.entries}>
             {(entry, index) => <WorkEntryRow entry={entry} busy={props.active && index() === props.entries.length - 1} />}
           </For>
-        )}
-      />
-    </Show>
+        </div>
+      )}
+    />
   );
 }
 
@@ -288,34 +299,46 @@ function WorkText(props: { text: string }) {
   );
 }
 
-/** Expanded work: intermediate texts as quiet paragraphs, the steps between them as groups. One indent, one size. */
+const workItemKey = (item: AiWorkItem): string =>
+  item.kind === "text" ? `text:${item.block.id}` : item.kind === "step" ? `step:${item.entry.id}` : `group:${item.id}`;
+
+/**
+ * Expanded work, one indent below the work line and one size: intermediate texts as quiet paragraphs, the steps between
+ * them directly, and housekeeping folded at step level. A row shown while this list is open never folds away under the
+ * reader, also when reasoning or arguments that would fold it arrive later; the next time it opens, it folds like in
+ * history.
+ */
 function AiWorkSteps(props: { blocks: AiTurnBlock[]; active: boolean }) {
-  const groups = createMemo(() => groupWorkBlocks(props.blocks));
-  const keyed = createMemo(
-    () => new Map(groups().map((group) => [group.kind === "text" ? `text:${group.block.id}` : `steps:${group.id}`, group])),
-  );
-  const keys = createMemo(() => [...keyed().keys()]);
+  const shown = new Set<string>();
+  const items = createMemo(() => {
+    const work = groupWorkBlocks(props.blocks, shown);
+    for (const item of work) if (item.kind === "step") shown.add(item.entry.id);
+    return new Map(work.map((item) => [workItemKey(item), item]));
+  });
+  const keys = createMemo(() => [...items().keys()]);
   return (
     <div class="ai-turn-steps">
       <For each={keys()}>
         {(key, index) => {
-          const group = () => keyed().get(key);
+          const item = () => items().get(key);
           const text = () => {
-            const value = group();
+            const value = item();
             return value?.kind === "text" ? value.block.text : undefined;
           };
-          const steps = () => {
-            const value = group();
-            return value?.kind === "steps" ? value : undefined;
+          const step = () => {
+            const value = item();
+            return value?.kind === "step" ? value.entry : undefined;
+          };
+          const group = () => {
+            const value = item();
+            return value?.kind === "housekeeping" ? value : undefined;
           };
+          const active = () => props.active && index() === keys().length - 1;
           return (
             <Switch>
-              <Match when={text() !== undefined}>
-                <WorkText text={text()!} />
-              </Match>
-              <Match when={steps()}>
-                {(value) => <WorkGroup id={value().id} entries={value().entries} active={props.active && index() === keys().length - 1} />}
-              </Match>
+              <Match when={text()}>{(value) => <WorkText text={value()} />}</Match>
+              <Match when={step()}>{(entry) => <WorkEntryRow entry={entry()} busy={active()} />}</Match>
+              <Match when={group()}>{(value) => <HousekeepingGroup id={value().id} entries={value().entries} active={active()} />}</Match>
             </Switch>
           );
         }}
@@ -428,31 +451,47 @@ function AiTurnResultView(props: { result: Accessor<AiTurnResult | undefined>; r
   );
 }
 
-function AiReceipt(props: { action: AiTurnAction; stopped: boolean }) {
+type ReceiptState = Exclude<AiTurnActionState, "open" | "interaction">;
+
+/**
+ * One line for an action in place 4, the same element while it runs and once it is done, rejected, failed, or not run.
+ * It names the action in the reader's language with what it acted on, such as "Rejected: Run code · report.ts", or the
+ * application's own summary of what it did.
+ */
+function AiReceipt(props: { block: ToolBlock; state: ReceiptState; stopped: boolean }) {
   const locale = useLocale();
   const t = () => aiChatMessages(locale());
-  const block = () => props.action.block;
-  const title = () => block().presentation?.title ?? displayToolName(block().name, locale());
-  const links = () => (props.action.state === "done" ? resultLinks(block()) : []);
+  const block = () => props.block;
+  const subject = () => {
+    const title = block().presentation?.title ?? displayToolName(block().name, locale());
+    const target = toolTarget(block());
+    return target ? `${title} · ${target}` : title;
+  };
+  const links = () => (props.state === "done" ? resultLinks(block()) : []);
   const label = () => {
-    const state = props.action.state;
+    const state = props.state;
+    if (state === "running") return t().receiptRunning({ title: subject() });
     if (state === "done") {
       const summary = resultSummary(block());
       if (summary) return summary;
       // A tool that is not a Cloud action has no effect of its own to report; the receipt records the decision.
-      return block().presentation?.kind === "capability" ? t().receiptDone({ title: title() }) : t().receiptApproved({ title: title() });
+      return block().presentation?.kind === "capability"
+        ? t().receiptDone({ title: subject() })
+        : t().receiptApproved({ title: subject() });
     }
-    if (state === "rejected") return t().receiptRejected({ title: title() });
-    if (state === "failed") return t().receiptFailed({ title: title() });
-    return t().receiptNotRun({ title: title(), stopped: props.stopped });
+    if (state === "rejected") return t().receiptRejected({ title: subject() });
+    if (state === "failed") return t().receiptFailed({ title: subject() });
+    return t().receiptNotRun({ title: subject(), stopped: props.stopped });
   };
+  const declined = () => props.state === "rejected" || props.state === "not_run";
   return (
     <Chat.Activity
       class="ai-turn-receipt"
-      icon={aiToolIcon(block().name, block().presentation?.appIcon)}
-      accent={block().presentation?.appAccent}
+      icon={declined() ? "ti ti-circle-off" : aiToolIcon(block().name, block().presentation?.appIcon)}
+      accent={declined() ? undefined : block().presentation?.appAccent}
       label={label()}
-      description={props.action.state === "failed" ? capabilityErrorDescription(block().result) : undefined}
+      busy={props.state === "running"}
+      description={props.state === "failed" ? capabilityErrorDescription(block().result) : undefined}
       trailing={links().length > 0 ? <ResultLinks links={links()} /> : undefined}
     />
   );
@@ -463,8 +502,26 @@ function AiTurnActionView(props: { action: Accessor<AiTurnAction | undefined>; t
   let row!: HTMLDivElement;
   // Set while focus is in this place, including after the focused control disappeared with the decided card.
   let focusedHere = false;
+  // The decision the server accepted for a card here; its receipt replaces the card before the turn reports it. It
+  // belongs to the call it answered: code that asks again shows the next request on the same block as a new card.
+  const [decided, setDecided] = createSignal<AiApprovalDecision | null>(null);
   const action = () => props.action();
   const state = () => action()?.state;
+  const decision = () => {
+    const current = action();
+    const value = decided();
+    return current && value?.callId === current.block.callId ? value.approved : null;
+  };
+  const card = () => {
+    const current = action();
+    return current?.state === "open" && current.block.status === "awaiting_approval" && decision() === null ? current.block : undefined;
+  };
+  const receipt = (): ReceiptState | undefined => {
+    const current = action();
+    if (!current || card()) return undefined;
+    if (current.state === "open" && current.block.status === "awaiting_approval") return decision() ? "running" : "rejected";
+    return current.state === "open" || current.state === "interaction" ? undefined : current.state;
+  };
   // Screen readers hear a waiting approval once, as one short line instead of the whole card, without moving focus.
   createEffect(
     on(state, (next, previous) => {
@@ -477,13 +534,17 @@ function AiTurnActionView(props: { action: Accessor<AiTurnAction | undefined>; t
       );
     }),
   );
-  // A card the user decided becomes its receipt in place. Focus stays on that place without scrolling.
+  // A card the user decided becomes its receipt in place, once, as the direct result of the decision. Focus stays on
+  // that place without scrolling.
   createEffect(
-    on(state, (next, previous) => {
-      if (previous !== "open" || next === "open" || !focusedHere || typeof document === "undefined") return;
-      const focused = document.activeElement;
-      if (!focused || focused === document.body || row.contains(focused)) row.focus({ preventScroll: true });
-    }),
+    on(
+      () => card() !== undefined,
+      (open, wasOpen) => {
+        if (!wasOpen || open || !focusedHere || typeof document === "undefined") return;
+        const focused = document.activeElement;
+        if (!focused || focused === document.body || row.contains(focused)) row.focus({ preventScroll: true });
+      },
+    ),
   );
   return (
     <div
@@ -500,11 +561,12 @@ function AiTurnActionView(props: { action: Accessor<AiTurnAction | undefined>; t
     >
       <Show when={action()}>
         {(current) => (
-          <Switch fallback={<AiReceipt action={current()} stopped={props.phase === "stopped"} />}>
-            <Match when={current().state === "open" && current().block.status === "awaiting_approval"}>
-              <ApprovalBlockView turnId={props.turnId} block={current().block} />
+          <Switch>
+            <Match when={card()}>{(block) => <ApprovalBlockView turnId={props.turnId} block={block()} onDecided={setDecided} />}</Match>
+            <Match when={receipt()}>
+              {(receiptState) => <AiReceipt block={current().block} state={receiptState()} stopped={props.phase === "stopped"} />}
             </Match>
-            <Match when={current().state === "open" || current().state === "interaction"}>
+            <Match when={true}>
               <Switch
                 fallback={
                   <Chat.Activity
@@ -522,14 +584,6 @@ function AiTurnActionView(props: { action: Accessor<AiTurnAction | undefined>; t
                 </Match>
               </Switch>
             </Match>
-            <Match when={current().state === "running"}>
-              <Chat.Activity
-                label={current().block.presentation?.title ?? displayToolName(current().block.name, locale())}
-                icon={aiToolIcon(current().block.name, current().block.presentation?.appIcon)}
-                accent={current().block.presentation?.appAccent}
-                busy
-              />
-            </Match>
           </Switch>
         )}
       </Show>

package/src/ai/protocol.ts

@@ -45,7 +45,10 @@ export type AiTurnBlock =
       isError?: boolean;
       /** Present while status is awaiting_approval. */
       approval?: { message?: string; review?: CapabilityActionReview; allowAlways: boolean };
-      /** The user approved this call in the chat; the decided approval stays visible as a receipt. */
+      /**
+       * `true` once the user approved this call in the chat; `false` when its turn ended while the approval still
+       * waited. Either way the approval stays visible as a receipt.
+       */
       approved?: boolean;
       /** Present for frontend tools. */
       frontendMode?: AiFrontendToolMode;
@@ -224,7 +227,7 @@ export const buildBlocksFromMessages = (
     meta?: {
       steerId?: string;
       toolPresentations?: Record<string, AiToolPresentation>;
-      toolOutcomes?: Record<string, "rejected" | "approved">;
+      toolOutcomes?: Record<string, "rejected" | "approved" | "expired">;
     } | null;
   }[],
 ): AiTurnBlock[] => {
@@ -239,6 +242,7 @@ export const buildBlocksFromMessages = (
         } else if (block.type === "thinking") {
           blocks.push({ id: messageBlockId(seq, index), kind: "thinking", text: block.thinking });
         } else if (block.type === "tool_call") {
+          const outcome = meta?.toolOutcomes?.[block.id];
           toolIndex.set(block.id, blocks.length);
           blocks.push({
             id: toolBlockId(block.id),
@@ -248,8 +252,9 @@ export const buildBlocksFromMessages = (
             args: block.args,
             status: "running",
             presentation: meta?.toolPresentations?.[block.id],
-            // A turn that ended before an approved call returned records the approval on the call's message.
-            ...(meta?.toolOutcomes?.[block.id] === "approved" ? { approved: true } : {}),
+            // A turn that ended before an approved call returned records the approval on the call's message, and an
+            // approval it left waiting as expired.
+            ...(outcome === "approved" || outcome === "expired" ? { approved: outcome === "approved" } : {}),
           });
         }
       });

package/src/ai/store.ts

@@ -788,9 +788,10 @@ const messageSearchText = (message: Message): string => {
  * Record how a turn ended on its messages when its loop could not record it: a stop while an approval waits, a run
  * time limit, or a turn the sweep finalizes. History reads the ending from the last assistant message, so such a turn
  * never looks finished. A failure replaces the `aborted` that a loop cut off by its run time limit recorded, so the
- * limit never looks like a user stop. A call the user approved that never returned keeps its approval in history.
- * A failure's reason goes to the turn's last message, also when that is the user's own, so history can say why the
- * turn failed and what to do next.
+ * limit never looks like a user stop. A call the user approved that never returned keeps its approval in history, and
+ * one whose approval still waited records that the approval expired, so history shows it as not run. A failure's
+ * reason goes to the turn's last message, also when that is the user's own, so history can say why the turn failed and
+ * what to do next.
  */
 const recordTurnEnd = async (
   db: typeof sql,
@@ -829,8 +830,9 @@ const recordTurnEnd = async (
       )
         AND (loop_done_reason IS NULL OR loop_done_reason = ${replaces}::text)
     `;
-    // An approved call without a result keeps the decision on the message that holds the call. A decision on a custom
-    // approval belongs to the call that asked for it.
+    // An approved call without a result keeps the decision on the message that holds the call; an approval nobody
+    // answered is recorded as expired. A custom approval belongs to the call that asked for it, and one approved request
+    // of that call outweighs a later one that expired.
     await db`
       UPDATE ${db(table)} target
       SET meta = jsonb_set(
@@ -839,30 +841,35 @@ const recordTurnEnd = async (
         COALESCE(target.meta->'toolOutcomes', '{}'::jsonb) || outcomes.value
       )
       FROM (
-        SELECT message.id, jsonb_object_agg(approved.call_id, 'approved'::text) AS value
+        SELECT message.id, jsonb_object_agg(decided.call_id, decided.outcome) AS value
         FROM (
-          SELECT DISTINCT
+          SELECT
             CASE
               WHEN action.kind = 'custom_approval' THEN COALESCE(substring(action.call_id FROM '^(.*)-approval-[0-9]+$'), action.call_id)
               ELSE action.call_id
-            END AS call_id
+            END AS call_id,
+            CASE WHEN bool_or(action.resolved_event IS NOT NULL) THEN 'approved' ELSE 'expired' END AS outcome
           FROM ai.pending_actions action
           WHERE action.turn_id = ${input.turnId}
-            AND action.resolved_event->>'type' = 'approval_response'
-            AND action.resolved_event->>'approved' = 'true'
-        ) approved
+            AND action.kind IN ('approval', 'custom_approval')
+            AND (
+              action.resolved_event IS NULL
+              OR (action.resolved_event->>'type' = 'approval_response' AND action.resolved_event->>'approved' = 'true')
+            )
+          GROUP BY 1
+        ) decided
         JOIN ${db(table)} message
           ON message.conversation_id = ${input.conversationId}
           AND message.loop_id = ${input.turnId}::text
           AND message.role = 'assistant'
-          AND message.message->'content' @> jsonb_build_array(jsonb_build_object('type', 'tool_call', 'id', approved.call_id))
+          AND message.message->'content' @> jsonb_build_array(jsonb_build_object('type', 'tool_call', 'id', decided.call_id))
         WHERE NOT EXISTS (
           SELECT 1
           FROM ${db(table)} result
           WHERE result.conversation_id = ${input.conversationId}
             AND result.loop_id = ${input.turnId}::text
             AND result.role = 'tool_result'
-            AND result.message->>'callId' = approved.call_id
+            AND result.message->>'callId' = decided.call_id
         )
         GROUP BY message.id
       ) outcomes

package/src/ai/types.ts

@@ -300,7 +300,8 @@ export type AiStoredMessage = {
       trigger: "scheduled" | "manual";
     };
     toolPresentations?: Record<string, AiToolPresentation>;
-    toolOutcomes?: Record<string, "rejected" | "approved">;
+    /** How the person decided an approval; `expired` when the turn ended while it still waited. */
+    toolOutcomes?: Record<string, "rejected" | "approved" | "expired">;
     /** Why the turn failed, on the last message of its loop. The chat words it in the reader's language. */
     turnError?: AiTurnError;
   } | null;

package/src/api/admin-outgoing-mail.ts

@@ -3,8 +3,11 @@ import { type Context, Hono, type MiddlewareHandler } from "hono";
 import { describeRoute, validator } from "hono-openapi";
 import { z } from "zod";
 import {
+  AdminMailAppSchema,
   AdminMailRecordSchema,
   MailAppAccessSchema,
+  MailLogAccessSchema,
+  MailLogAppIdSchema,
   MailProfileInputSchema,
   MailProfileKeySchema,
   MailRetentionSchema,
@@ -235,6 +238,21 @@ export const createAdminOutgoingMailRoutes = (authenticate: MiddlewareHandler<Au
       await outgoingMailTest.send(c.req.param("key")!, c.req.valid("json").recipient, context(c));
       return c.json({ ok: true as const });
     })
+    .put(
+      "/apps/:appId/log-access",
+      describeRoute({
+        summary: "Set application mail log access",
+        tags: ["Outgoing mail"],
+        ...requiresAdmin,
+        responses: {
+          200: jsonResponse(AdminMailAppSchema, "Updated application access"),
+          400: jsonResponse(z.object({ code: z.literal("bad_input"), message: z.string() }), "Invalid log access"),
+        },
+      }),
+      validate("param", z.object({ appId: MailLogAppIdSchema }), "bad_input"),
+      validate("json", MailLogAccessSchema, "bad_input"),
+      async (c) => c.json(await outgoingMailStore.setAppLogAccess(c.req.valid("param").appId, c.req.valid("json"), context(c))),
+    )
     .get("/apps", async (c) => c.json(await outgoingMailStore.apps()))
     .put("/apps/:appId", validate("json", MailAppAccessSchema), async (c) =>
       c.json(await outgoingMailStore.setAppAccess(c.req.param("appId")!, c.req.valid("json"), context(c))),

package/src/cli/admin/outgoing-mail.ts

@@ -2,6 +2,8 @@ import {
   type AdminMailApp,
   type AdminMailProfile,
   type AdminMailRecord,
+  MailLogAccessSchema,
+  MailLogAppIdSchema,
   type MailPage,
   MailProfileInputSchema,
   type MailRetention,
@@ -181,8 +183,16 @@ export const outgoingMailCommands = [
       printJsonOrTable(
         ctx,
         result,
-        result.items.map((app) => ({ ...app, profiles: app.profiles.join(",") })),
-        [{ key: "appId" }, { key: "name" }, { key: "declared" }, { key: "mode" }, { key: "profiles" }],
+        result.items.map((app) => ({ ...app, reads: app.readDeclared, profiles: app.profiles.join(","), logApps: app.logApps.join(",") })),
+        [
+          { key: "appId" },
+          { key: "name" },
+          { key: "declared" },
+          { key: "reads" },
+          { key: "mode" },
+          { key: "profiles" },
+          { key: "logApps" },
+        ],
       );
     },
   }),
@@ -212,4 +222,22 @@ export const outgoingMailCommands = [
       );
     },
   }),
+  command("outgoing-mail apps set-log-access", {
+    summary: "Choose which other applications' mail logs an app may read",
+    args: { app: arg.required({ valueLabel: "app" }) },
+    flags: {
+      apps: flag.string({ description: "Comma-separated source application IDs" }),
+      ownOnly: flag.boolean({ description: "Remove all other application log grants" }),
+      yes: confirmFlag("Confirm application mail log access change"),
+    },
+    async run({ ctx, args, flags }) {
+      confirmed(flags.yes);
+      if ((flags.apps !== undefined) === !!flags.ownOnly) throw new Error("Choose exactly one of --apps or --own-only.");
+      const reader = MailLogAppIdSchema.safeParse(args.app);
+      const value = MailLogAccessSchema.safeParse({ apps: flags.apps?.split(",").map((app) => app.trim()) ?? [] });
+      if (!reader.success || args.app === "core" || !value.success || value.data.apps.includes(args.app))
+        throw new Error("Choose a valid reader and distinct source apps other than Core or the reader itself.");
+      print(ctx, await apiJson(ctx, "PUT", `${root}/apps/${encodeURIComponent(args.app)}/log-access`, value.data));
+    },
+  }),
 ];