@k2b/cloud 0.6.0 → 0.8.0

package/src/ai/client/controller.ts

@@ -4,6 +4,7 @@ import { type AiAttachmentRef, aiAttachmentMarker } from "../attachments";
 import { type AiStreamEvent, type AiTurnBlock, type AiTurnSnapshot, steerMessageBlockId } from "../protocol";
 import { type AiResourceMarker, aiResourceMarker } from "../resource-markers";
 import type {
+  AiClientToolId,
   AiConversation,
   AiConversationTimelineEntry,
   AiDraftContentPart,
@@ -18,6 +19,7 @@ import {
   activeTurnFromSnapshot,
   emptyProjection,
   mergeActiveTurn,
+  messagesWithPendingSend,
   reconcileActiveTurnActions,
   reduceProjection,
   visibleMessages,
@@ -25,6 +27,10 @@ import {
 import { type AiConversationStreamTransport, type AiStreamHandle, aiSseConversationStreamTransport } from "./transport";
 
 type ComposerDraftInput = {
+  draftContent?: AiDraftContentPart[];
+  /** Bind local content to the server draft it was actually based on. */
+  conversationId?: string;
+  expectedDraftRevision?: number;
   message?: string;
   content?: AiUserContentPart[];
   files?: File[];
@@ -36,6 +42,7 @@ export type AiChatRunStatus = "idle" | "streaming" | "waiting_for_action" | "sto
 export type AiStreamStatus = "idle" | "connecting" | "open" | "reconnecting";
 
 export type AiFrontendToolHandler = (request: {
+  conversationId: string;
   name: string;
   callId: string;
   args: unknown;
@@ -99,6 +106,8 @@ export type CreateAiChatControllerOptions = {
   /** Persist owner read state for conversation-list unread indicators. */
   trackViewedState?: boolean;
   frontendTools?: Record<string, AiFrontendToolHandler>;
+  /** Explicitly advertise only client tools with a connected handler. */
+  clientToolIds?: AiClientToolId[];
   /** Overrides the default SSE transport, for example with a shared WebSocket channel. */
   streamTransport?: AiConversationStreamTransport;
 };
@@ -141,6 +150,14 @@ export const createAiChatController = (options: CreateAiChatControllerOptions) =
   const [streamStatus, setStreamStatus] = createSignal<AiStreamStatus>("idle");
   const initialProjection = options.initialDetail ? detailToProjection(options.initialDetail) : emptyProjection();
   const [state, setState] = createStore<AiChatProjection>(initialProjection);
+  const completedDuringSend = new Map<string, string>();
+  const [pendingSends, setPendingSends] = createSignal<Record<string, AiStoredMessage | undefined>>({});
+  const clearPendingSend = (conversationId: string) =>
+    setPendingSends((current) => {
+      const next = { ...current };
+      delete next[conversationId];
+      return next;
+    });
 
   // Cache of projections for conversations opened this session (fast switching).
   const cache = new Map<string, AiChatProjection>();
@@ -207,7 +224,7 @@ export const createAiChatController = (options: CreateAiChatControllerOptions) =
   const error = () => globalError() ?? runError();
 
   const activeTurn = () => state.activeTurn;
-  const messages = createMemo(() => visibleMessages(state));
+  const messages = createMemo(() => messagesWithPendingSend(visibleMessages(state), pendingSends()[activeConversationId() ?? ""]));
   const runStatus = (): AiChatRunStatus => {
     const override = runStatusRaw();
     if (override) return override;
@@ -226,6 +243,7 @@ export const createAiChatController = (options: CreateAiChatControllerOptions) =
     const next = reduceProjection({ conversation: state.conversation, messages: state.messages, activeTurn: state.activeTurn }, event);
     setState(reconcile(next, { key: "id", merge: true }));
     cache.set(conversationId, next);
+    if (event.type === "turn_finished" && pendingSends()[conversationId]?.loopId === event.turnId) clearPendingSend(conversationId);
   };
 
   /**
@@ -241,6 +259,8 @@ export const createAiChatController = (options: CreateAiChatControllerOptions) =
       setProjection(detailToProjection(detail), session.conversationId);
       setHasMore(session.conversationId, detail.hasMoreMessages ?? false);
       if (detail.timeline) setTimeline(session.conversationId, detail.timeline);
+      if (event.type === "turn_finished" && pendingSends()[session.conversationId]?.loopId === event.turnId)
+        clearPendingSend(session.conversationId);
     } else reduceEvent(session.conversationId, event);
     setRunStatusRaw(null);
     void markConversationViewed(session.conversationId);
@@ -249,6 +269,9 @@ export const createAiChatController = (options: CreateAiChatControllerOptions) =
   const applyEvent = (session: AiStreamSession, event: AiStreamEvent) => {
     if (!isCurrentStreamSession(streamSession, session)) return;
     const conversationId = session.conversationId;
+    if (event.type === "turn_finished" && pendingSends()[conversationId]) {
+      completedDuringSend.set(conversationId, event.turnId);
+    }
 
     if (event.type === "state") setHasMore(conversationId, event.hasMoreMessages ?? false);
     const nextRunError = runErrorFromEvent(event, state.activeTurn?.turnId);
@@ -265,7 +288,7 @@ export const createAiChatController = (options: CreateAiChatControllerOptions) =
 
     reduceEvent(conversationId, event);
     if (event.type === "state" && loadingConversationId() === conversationId) setLoadingConversationId(null);
-    if (runStatusRaw() && runStatusRaw() !== "stopping") setRunStatusRaw(null);
+    if (runStatusRaw() && (runStatusRaw() !== "stopping" || !state.activeTurn)) setRunStatusRaw(null);
 
     if (event.type === "turn_finished") {
       setRunStatusRaw(null);
@@ -338,7 +361,7 @@ export const createAiChatController = (options: CreateAiChatControllerOptions) =
       return false;
     }
     try {
-      const result = await handler({ name, callId, args, turnId });
+      const result = await handler({ name, callId, args, turnId, conversationId });
       return submitTurnActionForConversation(conversationId, turnId, callId, { type: "tool_result", result });
     } catch (toolError) {
       return submitTurnActionForConversation(conversationId, turnId, callId, {
@@ -394,6 +417,7 @@ export const createAiChatController = (options: CreateAiChatControllerOptions) =
     };
     cache.set(conversationId, next);
     setState(reconcile(next, { key: "id", merge: true }));
+    if (!next.activeTurn && runStatusRaw() === "stopping") setRunStatusRaw(null);
   };
 
   const openConversation = async (conversationId: string) => {
@@ -436,15 +460,25 @@ export const createAiChatController = (options: CreateAiChatControllerOptions) =
     return generation === conversationOpenGeneration ? ("failed" as const) : ("stale" as const);
   };
 
+  let conversationRefreshGeneration = 0;
   const refreshActiveConversation = async (): Promise<void> => {
     const conversationId = activeConversationId();
     if (!conversationId) return;
+    const refreshGeneration = ++conversationRefreshGeneration;
+    const openGeneration = conversationOpenGeneration;
     const detail = await request<AiConversationDetail>(
       `/conversations/${conversationId}`,
       { method: "GET" },
       "Failed to refresh conversation",
     );
-    if (!isActiveConversation(conversationId)) return;
+    if (
+      !isActiveConversation(conversationId) ||
+      refreshGeneration !== conversationRefreshGeneration ||
+      openGeneration !== conversationOpenGeneration
+    )
+      return;
+    const currentDraft = state.conversation?.draft;
+    if (currentDraft && currentDraft.revision > detail.conversation.draft.revision) detail.conversation.draft = currentDraft;
     const windowOldest = detail.messages[0]?.seq;
     const preservedOlder = windowOldest === undefined ? [] : state.messages.filter((message) => message.seq < windowOldest);
     setProjection({ ...detailToProjection(detail), messages: [...preservedOlder, ...detail.messages] }, conversationId);
@@ -653,7 +687,7 @@ export const createAiChatController = (options: CreateAiChatControllerOptions) =
       }
     }
     const content: AiDraftContentPart[] = [
-      ...textParts,
+      ...(input.draftContent ?? textParts),
       ...(input.resources ?? []).map((resource) => ({ type: "resource" as const, ...resource })),
       ...(input.storedFiles ?? []).map((file) => ({ type: "file" as const, ...file })),
       ...uploaded.map((file) => ({ type: "file" as const, ...file })),
@@ -661,10 +695,14 @@ export const createAiChatController = (options: CreateAiChatControllerOptions) =
     try {
       const draft = await request<AiConversation["draft"]>(
         `/conversations/${conversationId}/draft`,
-        { method: "PUT", body: JSON.stringify({ expectedRevision: conversation.draft.revision, content }) },
+        { method: "PUT", body: JSON.stringify({ expectedRevision: input.expectedDraftRevision ?? conversation.draft.revision, content }) },
         "Failed to save conversation draft",
       );
-      const nextConversation = { ...conversation, draft };
+      const current = isActiveConversation(conversationId) ? state.conversation : cache.get(conversationId)?.conversation;
+      const nextConversation = {
+        ...(current ?? conversation),
+        draft: current && current.draft.revision > draft.revision ? current.draft : draft,
+      };
       const projection = isActiveConversation(conversationId)
         ? { conversation: nextConversation, messages: state.messages, activeTurn: state.activeTurn }
         : { ...(cache.get(conversationId) ?? emptyProjection(nextConversation)), conversation: nextConversation };
@@ -687,36 +725,79 @@ export const createAiChatController = (options: CreateAiChatControllerOptions) =
   };
 
   const saveDraft = (input: ComposerDraftInput) => {
-    const targetConversation = ensureConversation();
+    const targetConversation = input.conversationId ? Promise.resolve(input.conversationId) : ensureConversation();
     return queueDraftOperation(async () => persistComposerDraft(input, await targetConversation));
   };
 
+  const queuedAttempts = new Map<string, { key: string; files?: File[]; id: string; saved: { revision: number } }>();
+  const queueMessage = (input: ComposerDraftInput & { modelProfileId?: string }): Promise<boolean> => {
+    if (!input.conversationId || !isComposerDraftSendable(input)) return Promise.resolve(false);
+    const conversationId = input.conversationId;
+    const key = JSON.stringify({
+      message: input.message,
+      content: input.content,
+      draftContent: input.draftContent,
+      resources: input.resources,
+      storedFiles: input.storedFiles,
+      model: input.modelProfileId,
+    });
+    return queueDraftOperation(async () => {
+      try {
+        const previous = queuedAttempts.get(conversationId);
+        const same =
+          previous?.key === key &&
+          (previous.files ?? []).length === (input.files ?? []).length &&
+          (previous.files ?? []).every((file, index) => file === input.files?.[index]);
+        const saved = same ? previous.saved : await persistComposerDraft(input, conversationId);
+        if (!saved) return false;
+        const queueId = same ? previous.id : crypto.randomUUID();
+        queuedAttempts.set(conversationId, { key, files: input.files, id: queueId, saved });
+        await request(
+          `/conversations/${conversationId}/turns`,
+          {
+            method: "POST",
+            body: JSON.stringify({
+              draftRevision: saved.revision,
+              queueId,
+              modelProfileId: input.modelProfileId,
+              clientToolIds: options.clientToolIds?.filter((id) => options.frontendTools?.[id]),
+            }),
+          },
+          "Failed to queue message",
+        );
+        if (isActiveConversation(conversationId)) {
+          if ((state.conversation?.draft.revision ?? 0) <= saved.revision)
+            setState("conversation", "draft", { content: [], revision: saved.revision + 1, updatedAt: new Date().toISOString() });
+        } else invalidateInactiveCache(conversationId);
+        queuedAttempts.delete(conversationId);
+        if (isActiveConversation(conversationId)) setGlobalError(null);
+        return true;
+      } catch (error) {
+        setConversationError(conversationId, error instanceof Error ? error.message : "Failed to queue message");
+        return false;
+      }
+    });
+  };
+
   const send = (input: ComposerDraftInput & { modelProfileId?: string }): Promise<boolean> => {
     if (!isComposerDraftSendable(input)) return Promise.resolve(false);
-    const targetConversation = ensureConversation();
+    const targetConversation = input.conversationId ? Promise.resolve(input.conversationId) : ensureConversation();
     return queueDraftOperation(async () => {
-      const savedDraft = await persistComposerDraft(input, await targetConversation);
-      if (!savedDraft) return false;
-      const conversationId = savedDraft.conversationId;
-      if (isActiveConversation(conversationId) && running()) return false;
-
+      const conversationId = await targetConversation;
+      if (!conversationId || (isActiveConversation(conversationId) && running())) return false;
       if (isActiveConversation(conversationId)) clearErrors();
       const baseProjection = isActiveConversation(conversationId)
         ? { conversation: state.conversation, messages: [...state.messages], activeTurn: state.activeTurn }
         : (cache.get(conversationId) ?? emptyProjection());
-
-      // Optimistic view renders attachments through the same marker format the server persists.
       const optimisticContent: AiUserContentPart[] = [
-        ...savedDraft.content.flatMap((part) => {
-          if (part.type === "text") return [{ type: "text" as const, text: part.text }];
-          if (part.type === "file") return [{ type: "text" as const, text: aiAttachmentMarker(part) }];
-          return [
-            {
-              type: "text" as const,
-              text: aiResourceMarker({ ref: part.ref, title: part.title, icon: part.icon, href: part.href }),
-            },
-          ];
-        }),
+        ...(input.content ?? []),
+        ...(!input.content?.length && input.message ? [{ type: "text" as const, text: input.message }] : []),
+        ...(input.resources ?? []).map((ref) => ({ type: "text" as const, text: aiResourceMarker(ref) })),
+        ...(input.storedFiles ?? []).map((file) => ({ type: "text" as const, text: aiAttachmentMarker(file) })),
+        ...(input.files ?? []).map((file) => ({
+          type: "text" as const,
+          text: aiAttachmentMarker({ path: `/${file.name}`, mediaType: file.type, size: file.size }),
+        })),
       ];
 
       // Optimistic: show the user message immediately.
@@ -738,39 +819,72 @@ export const createAiChatController = (options: CreateAiChatControllerOptions) =
         meta: null,
         createdAt: new Date().toISOString(),
       };
-      const optimisticProjection = { ...baseProjection, messages: [...baseProjection.messages, optimistic] };
-      cache.set(conversationId, optimisticProjection);
+      setPendingSends((current) => ({ ...current, [conversationId]: optimistic }));
       if (isActiveConversation(conversationId)) {
-        setState("messages", (prev) => [...prev, optimistic]);
         setRunStatusRaw("streaming");
       }
 
       try {
+        const savedDraft = await persistComposerDraft(input, conversationId);
+        if (!savedDraft) {
+          clearPendingSend(conversationId);
+          if (isActiveConversation(conversationId)) setRunStatusRaw("failed");
+          return false;
+        }
+        setPendingSends((current) => ({
+          ...current,
+          [conversationId]: {
+            ...optimistic,
+            meta: { submittedDraftRevision: savedDraft.revision },
+            message: {
+              role: "user",
+              content: savedDraft.content.map((part) => ({
+                type: "text",
+                text:
+                  part.type === "text"
+                    ? part.text
+                    : part.type === "file"
+                      ? aiAttachmentMarker(part)
+                      : part.type === "project-file"
+                        ? `Project file: ${part.path}`
+                        : aiResourceMarker({ ref: part.ref, title: part.title, icon: part.icon, href: part.href }),
+              })),
+            },
+          },
+        }));
         const result = await request<SubmitTurnResult>(
           `/conversations/${conversationId}/turns`,
           {
             method: "POST",
             body: JSON.stringify({
               draftRevision: savedDraft.revision,
+              clientToolIds: options.clientToolIds?.filter((id) => options.frontendTools?.[id]),
               modelProfileId: input.modelProfileId,
             }),
           },
           "AI request failed",
         );
+        const alreadyFinished = completedDuringSend.get(conversationId) === result.turn.id;
+        completedDuringSend.delete(conversationId);
+        if (alreadyFinished) clearPendingSend(conversationId);
+        else setPendingSends((current) => ({ ...current, [conversationId]: result.message }));
         if (invalidateInactiveCache(conversationId)) return true;
         // Replace the optimistic message with the persisted one.
-        setState("messages", (prev) => prev.map((message) => (message.id === optimistic.id ? result.message : message)));
+        setState("messages", (prev) => [...prev.filter((message) => message.id !== result.message.id), result.message]);
         setState(
           "activeTurn",
           (current) =>
-            current ?? {
-              turnId: result.turn.id,
-              attempt: 0,
-              seq: 0,
-              status: "running",
-              blocks: [],
-              modelProfileId: result.turn.modelProfileId,
-            },
+            current ??
+            (alreadyFinished
+              ? null
+              : {
+                  turnId: result.turn.id,
+                  attempt: 0,
+                  seq: 0,
+                  status: "running",
+                  blocks: [],
+                  modelProfileId: result.turn.modelProfileId,
+                }),
         );
         if (state.conversation) {
           setState("conversation", "draft", {
@@ -787,6 +901,8 @@ export const createAiChatController = (options: CreateAiChatControllerOptions) =
         }
         return true;
       } catch (sendError) {
+        completedDuringSend.delete(conversationId);
+        clearPendingSend(conversationId);
         if (invalidateInactiveCache(conversationId)) return false;
         setState("messages", (prev) => prev.filter((message) => message.id !== optimistic.id));
         cache.set(conversationId, { conversation: state.conversation, messages: state.messages, activeTurn: state.activeTurn });
@@ -1157,6 +1273,8 @@ export const createAiChatController = (options: CreateAiChatControllerOptions) =
     conversation: () => state.conversation,
     setActiveConversationId,
     messages,
+    /** Includes persisted model rounds still represented by live blocks in the timeline. */
+    usageMessages: () => state.messages,
     activeTurn,
     hasMoreHistory,
     loadingOlder: () => isActiveConversationLoading(activeConversationId(), loadingOlderConversationId()),
@@ -1175,6 +1293,7 @@ export const createAiChatController = (options: CreateAiChatControllerOptions) =
     refreshActiveConversation,
     createConversation,
     saveDraft,
+    queueMessage,
     send,
     steer,
     retrySteer,
@@ -1194,7 +1313,14 @@ export const createAiChatController = (options: CreateAiChatControllerOptions) =
 export type AiChatController = ReturnType<typeof createAiChatController>;
 
 const isComposerDraftSendable = (input: ComposerDraftInput): boolean =>
-  Boolean(input.message?.trim() || input.content?.length || input.files?.length || input.resources?.length || input.storedFiles?.length);
+  Boolean(
+    input.draftContent?.length ||
+      input.message?.trim() ||
+      input.content?.length ||
+      input.files?.length ||
+      input.resources?.length ||
+      input.storedFiles?.length,
+  );
 
 export const __aiControllerTest = {
   claimFrontendCall,

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

@@ -30,7 +30,7 @@ const bytesToBase64 = (bytes: Uint8Array): string => {
   return btoa(binary);
 };
 
-export const conversationFileSource = (baseUrl: string, conversationId: string): FileSource => {
+export const conversationFileSource = (baseUrl: string, conversationId: string): FileSource & { listFiles(): Promise<AiFileStat[]> } => {
   const filesUrl = (suffix = "", params?: Record<string, string>) => {
     const query = params ? `?${new URLSearchParams(params).toString()}` : "";
     return `${baseUrl}/conversations/${conversationId}/files${suffix}${query}`;
@@ -45,15 +45,19 @@ export const conversationFileSource = (baseUrl: string, conversationId: string):
     return (await response.json()) as T;
   };
 
+  const listFiles = async (): Promise<AiFileStat[]> =>
+    (await request<{ files: AiFileStat[] }>(filesUrl(), { method: "GET" }, "Failed to load files")).files;
+
   return {
+    previewPreferencesKey: "assistant.csv-preview",
+    listFiles,
     async list(): Promise<FileTreeEntry[]> {
-      const result = await request<{ files: AiFileStat[] }>(filesUrl(), { method: "GET" }, "Failed to load files");
-      return result.files.map((file) => ({
+      return (await listFiles()).map((file) => ({
         path: file.path,
         size: file.size,
         mediaType: file.mediaType,
         updatedAt: file.updatedAt,
-        badge: file.origin === "user" ? "upload" : undefined,
+        badge: file.dictationRecordedAt ? undefined : file.origin === "user" ? "upload" : undefined,
       }));
     },
 
@@ -62,7 +66,8 @@ export const conversationFileSource = (baseUrl: string, conversationId: string):
       if (!response.ok) throw new Error(await readError(response, "Failed to load file"));
       const mediaType = response.headers.get("Content-Type")?.split(";")[0]?.trim() || "application/octet-stream";
       const bytes = new Uint8Array(await response.arrayBuffer());
-      return isTextMediaType(mediaType)
+      const delimited = /\.(csv|tsv)$/i.test(path) || mediaType === "text/csv" || mediaType === "text/tab-separated-values";
+      return isTextMediaType(mediaType) && !delimited
         ? { encoding: "utf8", content: new TextDecoder().decode(bytes), mediaType }
         : { encoding: "base64", content: bytesToBase64(bytes), mediaType };
     },
@@ -79,10 +84,11 @@ export const conversationFileSource = (baseUrl: string, conversationId: string):
       await request(filesUrl("/rename"), { method: "POST", body: JSON.stringify({ from, to }) }, "Failed to rename file");
     },
 
-    async upload(_dirPath, files) {
+    async upload(dirPath, files) {
       for (const file of files) {
         const form = new FormData();
         form.append("file", file);
+        form.append("directory", dirPath);
         const response = await fetch(filesUrl(), { method: "POST", body: form });
         if (!response.ok) throw new Error(await readError(response, `Failed to upload ${file.name}`));
       }

package/src/ai/client/live-connection.ts

@@ -63,6 +63,7 @@ export const createAiLiveConnection = (options: CreateAiLiveConnectionOptions):
 
   socket = createLiveWebSocket<AiLiveServerMessage>({
     url: options.url ?? "/api/ai/live",
+    activity: "always",
     initialCursor: options.initialCursor,
     subscribe: (cursor) => ({
       type: AI_LIVE_WS_TYPE.subscribe,

package/src/ai/client/projection.ts

@@ -23,6 +23,18 @@ export const emptyProjection = (conversation: AiConversation | null = null): AiC
   activeTurn: null,
 });
 
+/** A local send is an overlay, never part of a replaceable server snapshot. */
+export const messagesWithPendingSend = (messages: AiStoredMessage[], pending?: AiStoredMessage): AiStoredMessage[] => {
+  if (!pending) return messages;
+  const revision = pending.meta?.submittedDraftRevision;
+  const confirmed = messages.some(
+    (message) =>
+      message.id === pending.id ||
+      (revision !== undefined && message.message.role === "user" && message.meta?.submittedDraftRevision === revision),
+  );
+  return confirmed ? messages : [...messages, pending];
+};
+
 const mergeMessages = (existing: AiStoredMessage[], incoming: AiStoredMessage[]): AiStoredMessage[] => {
   if (incoming.length === 0) return existing;
   const byId = new Map(existing.map((message) => [message.id, message]));
@@ -69,19 +81,16 @@ const normalizeCustomApprovalBlocks = (blocks: AiTurnBlock[]): AiTurnBlock[] =>
   return normalized;
 };
 
-/** Never let a same-turn DB/SSE snapshot remove blocks the browser already observed. */
+/** A complete snapshot replaces its baseline; stale snapshots cannot resurrect old block IDs. */
 export const mergeActiveTurn = (previous: AiActiveTurn | null, incoming: AiActiveTurn | null): AiActiveTurn | null => {
   if (!previous || !incoming || previous.turnId !== incoming.turnId) return incoming;
   if (previous.attempt !== incoming.attempt) return incoming.attempt > previous.attempt ? incoming : previous;
-
-  const incomingIsNewer = incoming.seq >= previous.seq;
-  const blocks = incomingIsNewer ? overlayBlocks(previous.blocks, incoming.blocks) : overlayBlocks(incoming.blocks, previous.blocks);
-  return {
-    ...(incomingIsNewer ? incoming : previous),
-    seq: Math.max(previous.seq, incoming.seq),
-    blocks,
-    status: deriveStatus(blocks),
-  };
+  if (incoming.seq < previous.seq) return previous;
+  // Locally submitted steering may not have reached the snapshot yet.
+  const pendingSteers = previous.blocks.filter((block) => block.kind === "steer_message" && block.status !== "consumed");
+  const known = new Set(incoming.blocks.map((block) => block.id));
+  const blocks = [...incoming.blocks, ...pendingSteers.filter((block) => !known.has(block.id))];
+  return { ...incoming, blocks, status: deriveStatus(blocks) };
 };
 
 export const reconcileActiveTurnActions = (
@@ -141,7 +150,7 @@ export const reduceWireEvent = (state: AiChatProjection, event: AiWireEvent): Ai
   const active = state.activeTurn;
 
   if (event.type === "turn_started") {
-    if (active && active.turnId === event.turnId && event.attempt < active.attempt) return state;
+    if (active && active.turnId === event.turnId && !isNewerWireEvent(event, active)) return state;
     const pendingSteers =
       active?.turnId === event.turnId ? active.blocks.filter((block) => block.kind === "steer_message" && block.status !== "consumed") : [];
     const blocks = event.blocks ? overlayBlocks(normalizeCustomApprovalBlocks(event.blocks), pendingSteers) : pendingSteers;
@@ -163,6 +172,15 @@ export const reduceWireEvent = (state: AiChatProjection, event: AiWireEvent): Ai
     return { ...state, messages: mergeMessages(state.messages, event.messages ?? []), activeTurn: null };
   }
 
+  if (event.type === "message_saved") {
+    if (!active || active.turnId !== event.turnId || !isNewerWireEvent(event, active)) return state;
+    return {
+      ...state,
+      messages: mergeMessages(state.messages, [event.message]),
+      activeTurn: { ...active, seq: event.seq, attempt: event.attempt },
+    };
+  }
+
   // block_set / block_delta
   if (!active || active.turnId !== event.turnId) return state;
   if (!isNewerWireEvent(event, active)) return state;

package/src/ai/client/transport.ts

@@ -21,6 +21,11 @@ const CONNECT_TIMEOUT_MS = 10_000;
 export async function* parseAiSse(response: Response, signal: AbortSignal): AsyncGenerator<AiStreamEvent> {
   const reader = response.body?.getReader();
   if (!reader) return;
+  const cancel = () => {
+    void reader.cancel().catch(() => undefined);
+  };
+  signal.addEventListener("abort", cancel, { once: true });
+  if (signal.aborted) cancel();
   const decoder = new TextDecoder();
   let buffer = "";
   try {
@@ -40,6 +45,7 @@ export async function* parseAiSse(response: Response, signal: AbortSignal): Asyn
       }
     }
   } finally {
+    signal.removeEventListener("abort", cancel);
     await reader.cancel().catch(() => undefined);
   }
 }

package/src/ai/code-capability-routes.ts

@@ -0,0 +1,105 @@
+import { type Context, Hono } from "hono";
+import { z } from "zod";
+import { readBoundedJson } from "../_internal/bounded-json";
+import { dispatchCapability } from "../api/capabilities";
+import { dispatchCapabilityStream } from "../api/capability-streams";
+import { CAPABILITY_MAX_REQUEST_BYTES } from "../contracts/capabilities";
+import { type AuthContext, getLocale, type RequestAuthority } from "../server";
+import { requireInvocation } from "../server/middleware/invocation";
+import { getMandate } from "../services/mandates";
+import { codeCapabilityOperation } from "./code-capability-transport";
+import { authorizeCodeExecution } from "./code-execution";
+import { aiConversations } from "./store";
+
+const Input = z
+  .object({ input: z.unknown() })
+  .strict()
+  .refine((value) => Object.hasOwn(value, "input"));
+const denied = () => Response.json({ code: "ACCESS_DENIED", message: "Code execution is no longer authorized" }, { status: 403 });
+
+/** Core-only continuation of a code turn, not a general invocation exchange. */
+export function createCodeCapabilityRoutes(
+  dependencies: {
+    invocation?: Parameters<typeof requireInvocation>[1];
+    store?: Pick<typeof aiConversations, "getConversation" | "getTurn" | "getActiveTurn" | "getTurnRunConfig">;
+    getMandate?: typeof getMandate;
+    dispatch?: typeof dispatchCapability;
+    stream?: typeof dispatchCapabilityStream;
+  } = {},
+) {
+  const store = dependencies.store ?? aiConversations;
+  // This Core-only exchange resumes the verified turn; background calls also pass
+  // their persisted mandate to the dispatcher. Ordinary
+  // app invocations remain non-exchangeable; this is not an interactive cookie.
+  const turnAuthority = (c: Context<AuthContext>): RequestAuthority => ({
+    actor: c.get("actor"),
+    accessSubject: c.get("accessSubject"),
+    credentialKind: "session",
+    scopes: [],
+  });
+  const invoke = async (c: Context<AuthContext>, review = false) => {
+    const body = await readBoundedJson(c.req.raw, CAPABILITY_MAX_REQUEST_BYTES);
+    const input = body.ok ? Input.safeParse(body.data) : null;
+    if (!input?.success) return Response.json({ code: "VALIDATION_FAILED", message: "Invalid capability input" }, { status: 400 });
+    const conversation = await store.getConversation({ conversationId: c.req.param("conversationId")! });
+    const appId = c.req.param("appId")!;
+    const capabilityId = c.req.param("capabilityId")!;
+    if (conversation?.allowedTools && !conversation.allowedTools.includes(`${appId}.${capabilityId}`)) return denied();
+    const config = await store.getTurnRunConfig({ conversationId: c.req.param("conversationId")!, turnId: c.req.param("turnId")! });
+    if (!config || config.kind === "compact") return denied();
+    return (dependencies.dispatch ?? dispatchCapability)({
+      request: c.req.raw,
+      authority: turnAuthority(c),
+      origin: "assistant",
+      continuation: codeCapabilityOperation(c.req.param("conversationId")!, c.req.param("turnId")!),
+      mandate: config.mandate ? { mandateId: config.mandate.id, mandateRevision: config.mandate.revision, ownerAppId: "core" } : undefined,
+      review,
+      kind: review || c.req.param("kind") === "actions" ? "actions" : "queries",
+      appId,
+      capabilityId,
+      input: input.data.input,
+      locale: getLocale(c),
+    });
+  };
+  return new Hono<AuthContext>()
+    .use("/:conversationId/:turnId/*", async (c, next) => {
+      await next();
+      c.header("Cache-Control", "no-store");
+    })
+    .use(
+      "/:conversationId/:turnId/*",
+      requireInvocation((c) => {
+        const conversationId = z.uuid().safeParse(c.req.param("conversationId"));
+        const turnId = z.uuid().safeParse(c.req.param("turnId"));
+        return conversationId.success && turnId.success
+          ? { targetAppId: "core", operation: codeCapabilityOperation(conversationId.data, turnId.data), schemaHash: null }
+          : null;
+      }, dependencies.invocation),
+    )
+    .use("/:conversationId/:turnId/*", async (c, next) => {
+      const actor = c.get("actor");
+      if (actor.kind !== "user" || actor.delegation?.callingAppId !== "assistant" || actor.delegation.credentialKind !== "session")
+        return denied();
+      const conversationId = c.req.param("conversationId")!;
+      const turnId = c.req.param("turnId")!;
+      try {
+        await authorizeCodeExecution(conversationId, turnId, actor.user.id, { store, getMandate: dependencies.getMandate ?? getMandate });
+      } catch {
+        return denied();
+      }
+      await next();
+    })
+    .post("/:conversationId/:turnId/capabilities/v1/actions/:appId/:capabilityId/review", (c) => invoke(c, true))
+    .post("/:conversationId/:turnId/capabilities/v1/:kind{queries|actions}/:appId/:capabilityId", (c) => invoke(c))
+    .post("/:conversationId/:turnId/capabilities/v1/streams/:verb", async (c) => {
+      const config = await store.getTurnRunConfig({ conversationId: c.req.param("conversationId")!, turnId: c.req.param("turnId")! });
+      if (!config || config.kind === "compact" || config.mandate) return denied();
+      return (dependencies.stream ?? dispatchCapabilityStream)(c.req.raw, turnAuthority(c), c.req.param("verb"), {
+        continuation: codeCapabilityOperation(c.req.param("conversationId")!, c.req.param("turnId")!),
+        allow: async ({ appId, capabilityId }) => {
+          const conversation = await store.getConversation({ conversationId: c.req.param("conversationId")! });
+          return !!conversation && (!conversation.allowedTools || conversation.allowedTools.includes(`${appId}.${capabilityId}`));
+        },
+      });
+    });
+}