@k2b/cloud 0.6.0-rc.0 → 0.7.0

package/src/ai/routes.ts

@@ -1,3 +1,12 @@
+import { getAiChatQuotas } from "./chat-quotas";
+import { enqueueChatMessage, listQueuedMessages, updateQueuedMessage, editQueuedMessage, queuedMessageAccepted, AiMessageQueueConflict } from "./message-queue";
+import { prepareAiChatTurn, wakeAiMessageQueue } from "./runtime";
+import { bodyLimit } from "hono/body-limit";
+import { AI_AUDIO_MAX_BYTES } from "./audio-format";
+import { aiDictations, AiDictationConflict, AiDictationStartSchema, AiDictationListSchema } from "./dictations";
+import { enqueueAiDictation } from "./dictation-runtime";
+import { resolveAiAudioModel } from "./transcription";
+import { aiModelAccess } from "./model-access";
 import { type Context, Hono } from "hono";
 import { z } from "zod";
 import { listCapabilities } from "../_internal/registry";
@@ -16,6 +25,7 @@ import {
   v,
 } from "../server";
 import { coreSettings } from "../services/settings/api";
+import { logger } from "../services/logging";
 import type { AiToolApprovalContext } from "./approvals";
 import { assistantAiSettingsState, listAssistantAiModels, selectAssistantAiModelId } from "./assistant-models";
 import { buildAiCapabilityCatalog } from "./capabilities";
@@ -102,6 +112,10 @@ const ConversationListQuerySchema = z
       .enum(["true", "false"])
       .transform((value) => value === "true")
       .optional(),
+    done: z
+      .enum(["true", "false"])
+      .transform((value) => value === "true")
+      .optional(),
     status: z.enum(["running", "needs_attention", "failed", "unread"]).optional(),
     projectId: z.string().regex(AI_SHORT_ID_PATTERN).optional(),
     unassigned: z
@@ -123,6 +137,7 @@ const ConversationMetadataInputSchema = z.object({
 });
 
 const ConversationProjectInputSchema = z.object({
+  onlyUnassigned: z.boolean().optional(),
   projectId: z.string().regex(AI_SHORT_ID_PATTERN).nullable(),
 });
 
@@ -212,12 +227,13 @@ const rememberLastUsedModel = (actor: RequestActor, modelProfileId: string | nul
 };
 
 const conversationDetail = async (conversation: AiConversation, subject: AccessSubject) => {
-  const [state, timeline] = await Promise.all([
+  const [state, timeline, publicView] = await Promise.all([
     loadAiStreamState(conversation),
     aiConversations.listConversationTimeline({ conversationId: conversation.id }),
+    publicConversationFor(conversation, subject),
   ]);
   return {
-    conversation: await publicConversationFor(conversation, subject),
+    conversation: publicView,
     messages: state.messages.map((message) => ({ ...message, id: message.shortId })),
     hasMoreMessages: state.hasMoreMessages ?? false,
     activeTurn: state.activeTurn,
@@ -284,6 +300,10 @@ export const aiRoutes = (() => {
       .get("/status", async (c) => {
         return respond(c, ok(await assistantAiSettingsState(c.get("accessSubject"))));
       })
+      .get("/quotas", async (c) => {
+        c.header("Cache-Control", "no-store");
+        return c.json(await getAiChatQuotas(c.get("accessSubject")));
+      })
       .get("/models", async (c) => {
         return respond(c, ok(await listAssistantAiModels(c.get("accessSubject"))));
       })
@@ -428,6 +448,7 @@ export const aiRoutes = (() => {
                 ownerUserId: ctx.ownerUserId,
                 search: query.q,
                 archived: query.archived,
+                done: query.done,
                 status: query.status,
                 projectId: project?.id,
                 unassigned: query.unassigned,
@@ -448,6 +469,7 @@ export const aiRoutes = (() => {
           ownerUserId: ctx.ownerUserId,
           search: query.q,
           archived: query.archived,
+          done: query.done,
           status: query.status,
           projectId: project?.id,
           unassigned: query.unassigned,
@@ -552,7 +574,7 @@ export const aiRoutes = (() => {
         if (ctx instanceof Response) return ctx;
         const conversation = await loadConversation(c, ctx);
         if (!conversation) return notFound(c);
-        const messageId = c.req.param("messageId");
+        const messageId = (c.req.param("messageId") ?? "");
         if (!messageId) return respond(c, fail(err.badInput("Invalid message id.")));
         const input = c.req.valid("json");
         const feedback = await aiConversations.setMessageFeedback({
@@ -571,7 +593,7 @@ export const aiRoutes = (() => {
         if (ctx instanceof Response) return ctx;
         const conversation = await loadConversation(c, ctx);
         if (!conversation) return notFound(c);
-        const messageId = c.req.param("messageId");
+        const messageId = (c.req.param("messageId") ?? "");
         if (!messageId) return respond(c, fail(err.badInput("Invalid message id.")));
         return (await aiConversations.clearMessageFeedback({
           conversationId: conversation.id,
@@ -650,8 +672,10 @@ export const aiRoutes = (() => {
           conversationId: conversation.id,
           ownerUserId: ctx.ownerUserId,
           projectId: project?.id ?? null,
+          onlyUnassigned: body.onlyUnassigned,
         });
         if (!result.ok) {
+          if (result.reason === "already_assigned") return respond(c, fail(err.conflict("This chat already belongs to a Project.")));
           if (result.reason === "active_turn") {
             return respond(c, fail(err.conflict("Wait for the active turn before changing the Project.")));
           }
@@ -683,6 +707,22 @@ export const aiRoutes = (() => {
         });
         return updated ? respond(c, ok(await publicConversationFor(updated, c.get("accessSubject")))) : notFound(c);
       })
+      .put("/conversations/:conversationId/done", v("json", z.object({ done: z.boolean().nullable() })), async (c) => {
+        const ctx = await resolveContext(c);
+        if (ctx instanceof Response) return ctx;
+        const conversation = await loadConversation(c, ctx);
+        if (!conversation) return notFound(c);
+        const result = await aiConversations.setConversationDone({
+          conversationId: conversation.id,
+          ownerUserId: ctx.ownerUserId,
+          done: c.req.valid("json").done,
+        });
+        if (!result.ok)
+          return result.reason === "active_turn"
+            ? respond(c, fail(err.conflict("Stop the current response before marking this chat done.")))
+            : notFound(c);
+        return respond(c, ok(await publicConversationFor(result.conversation, c.get("accessSubject"))));
+      })
       .post("/conversations/:conversationId/archive", async (c) => {
         const ctx = await resolveContext(c);
         if (ctx instanceof Response) return ctx;
@@ -720,6 +760,37 @@ export const aiRoutes = (() => {
         });
         return viewed ? respond(c, ok({ ok: true })) : notFound(c);
       })
+      .get("/conversations/:conversationId/queue", async (c) => {
+        const ctx = await resolveContext(c);
+        if (ctx instanceof Response) return ctx;
+        const conversation = await loadConversation(c, ctx);
+        return conversation ? respond(c, ok(await listQueuedMessages(conversation.id))) : notFound(c);
+      })
+      .patch("/conversations/:conversationId/queue/:messageId", v("json", z.object({text:z.string().trim().min(1).max(20000)}).strict()), async (c) => {
+        const ctx = await resolveContext(c);
+        if (ctx instanceof Response) return ctx;
+        const conversation = await loadConversation(c, ctx);
+        if (!conversation || !z.uuid().safeParse(c.req.param("messageId")).success) return notFound(c);
+        return await editQueuedMessage(conversation.id,(c.req.param("messageId") ?? ""),c.req.valid("json").text) ? respond(c,ok({ok:true})) : notFound(c);
+      })
+      .delete("/conversations/:conversationId/queue/:messageId", async (c) => {
+        const ctx = await resolveContext(c);
+        if (ctx instanceof Response) return ctx;
+        const conversation = await loadConversation(c, ctx);
+        if (!conversation || !z.uuid().safeParse(c.req.param("messageId")).success) return notFound(c);
+        if (!await updateQueuedMessage(conversation.id, (c.req.param("messageId") ?? ""), "cancel")) return notFound(c);
+        wakeAiMessageQueue(conversation.id);
+        return respond(c, ok({ok:true}));
+      })
+      .post("/conversations/:conversationId/queue/:messageId/retry", async (c) => {
+        const ctx = await resolveContext(c);
+        if (ctx instanceof Response) return ctx;
+        const conversation = await loadConversation(c, ctx);
+        if (!conversation || !z.uuid().safeParse(c.req.param("messageId")).success) return notFound(c);
+        if (!await updateQueuedMessage(conversation.id, (c.req.param("messageId") ?? ""), "retry")) return notFound(c);
+        wakeAiMessageQueue(conversation.id);
+        return respond(c, ok({ok:true}));
+      })
       .put("/conversations/:conversationId/draft", v("json", AiSaveConversationDraftInputSchema), async (c) => {
         const ctx = await resolveContext(c);
         if (ctx instanceof Response) return ctx;
@@ -749,6 +820,7 @@ export const aiRoutes = (() => {
         const conversation = await loadConversation(c, ctx);
         if (!conversation) return notFound(c);
         const body = c.req.valid("json");
+        if (body.queueId && await queuedMessageAccepted(conversation.id, body.queueId)) return respond(c,ok({queued:true}));
         if (conversation.draft.revision !== body.draftRevision) {
           return respond(c, fail(err.conflict("The conversation draft changed in another session.")));
         }
@@ -756,6 +828,7 @@ export const aiRoutes = (() => {
         const resourceParts = conversation.draft.content.filter((part) => part.type === "resource");
         const turnContent = conversation.draft.content.map((part) => {
           if (part.type === "text") return { type: "text" as const, text: part.text };
+          if (part.type === "project-file") return { type: "text" as const, text: `Project file: ${part.path}` };
           if (part.type === "file") {
             return { type: "attachment" as const, path: part.path, mediaType: part.mediaType, size: part.size };
           }
@@ -768,8 +841,8 @@ export const aiRoutes = (() => {
         const project = conversation.projectId ? await aiProjects.snapshot(conversation.projectId, c.get("accessSubject")) : null;
         if (conversation.projectId && !project) return respond(c, fail(err.notFound("Project")));
         try {
-          const result = await submitAiChatTurn({
-            assistantChat: true,
+          const submission = {
+            assistantChat: true as const,
             conversationId: conversation.id,
             chatId: conversation.shortId,
             input,
@@ -780,7 +853,7 @@ export const aiRoutes = (() => {
             modelPolicy: ctx.modelPolicy,
             project: project ?? undefined,
             clientToolIds: body.clientToolIds,
-            toolSource: { kind: "default", appTools: true },
+            toolSource: { kind: "default" as const, appTools: true },
             toolApprovalContext: ctx.toolApprovalContext,
             expectedDraftRevision: body.draftRevision,
             expectedProjectId: conversation.projectId,
@@ -788,7 +861,13 @@ export const aiRoutes = (() => {
             expectedFiles: conversation.draft.content.flatMap((part) =>
               part.type === "file" ? [{ path: part.path, version: part.version }] : [],
             ),
-          });
+          };
+          if (body.queueId) {
+            await enqueueChatMessage(body.queueId, await prepareAiChatTurn(submission), conversation.draft.content);
+            wakeAiMessageQueue(conversation.id);
+            return respond(c, ok({ queued: true }));
+          }
+          const result = await submitAiChatTurn(submission);
           rememberLastUsedModel(ctx.actor, result.turn.modelProfileId);
           return respond(
             c,
@@ -803,6 +882,7 @@ export const aiRoutes = (() => {
             201,
           );
         } catch (error) {
+          if (error instanceof AiMessageQueueConflict || (error instanceof Error && error.message === "Queued messages must be sent first.")) return respond(c,fail(err.conflict(error.message)));
           return toAiErrorResponse(c, error);
         }
       })
@@ -832,7 +912,7 @@ export const aiRoutes = (() => {
         if (ctx instanceof Response) return ctx;
         const conversation = await loadConversation(c, ctx);
         if (!conversation) return notFound(c);
-        const messageId = c.req.param("messageId");
+        const messageId = (c.req.param("messageId") ?? "");
 
         const messages = await aiConversations.listMessages({ conversationId: conversation.id });
         const target = messages.find((m) => m.shortId === messageId);
@@ -881,6 +961,7 @@ export const aiRoutes = (() => {
             truncateFromSeq: target.seq,
             fileSnapshot: originalRunConfig?.kind !== "compact" ? originalRunConfig?.files : undefined,
             retrySourceTurnId: target.loopId ?? undefined,
+            clientToolIds: originalRunConfig?.kind !== "compact" ? originalRunConfig?.clientToolIds : undefined,
           });
           rememberLastUsedModel(ctx.actor, result.turn.modelProfileId);
           return respond(
@@ -904,7 +985,7 @@ export const aiRoutes = (() => {
         if (ctx instanceof Response) return ctx;
         const conversation = await loadConversation(c, ctx);
         if (!conversation) return notFound(c);
-        const messageId = c.req.param("messageId");
+        const messageId = (c.req.param("messageId") ?? "");
 
         const messages = await aiConversations.listMessages({ conversationId: conversation.id });
         const target = messages.find((m) => m.shortId === messageId);
@@ -1029,6 +1110,123 @@ export const aiRoutes = (() => {
         const files = await aiFileStore.list({ conversationId: conversation.id, prefix: c.req.valid("query").prefix ?? "/" });
         return respond(c, ok({ files, totalBytes: await aiFileStore.totalBytes(conversation.id) }));
       })
+      .post("/conversations/:conversationId/dictations", bodyLimit({ maxSize: AI_AUDIO_MAX_BYTES + 65_536 }), async (c) => {
+        const ctx = await resolveContext(c);
+        if (ctx instanceof Response) return ctx;
+        const conversation = await loadConversation(c, ctx);
+        if (!conversation) return notFound(c);
+        try {
+          const form = await c.req.formData();
+          const file = form.get("file");
+          if (!(file instanceof File)) return respond(c, fail(err.badInput("Attach one audio recording.")));
+          const options = AiDictationStartSchema.parse({
+            operationId: form.get("operationId"),
+            language: form.get("language") ?? undefined,
+          });
+          const dictation = await aiDictations.start({
+            ...options,
+            conversationId: conversation.id,
+            userId: ctx.ownerUserId,
+            bytes: new Uint8Array(await file.arrayBuffer()),
+            resolveModel: async () => {
+              const model = await resolveAiAudioModel({ allowedDataBoundaries: ctx.modelPolicy.allowedDataBoundaries });
+              await aiModelAccess.assertAllowed(model.profile.id, c.get("accessSubject"));
+              return model;
+            },
+          });
+          await enqueueAiDictation(dictation.id).catch(() => undefined); // The DB sweep heals failed delivery.
+          return respond(c, ok(dictation));
+        } catch (error) {
+          return respond(
+            c,
+            fail(
+              error instanceof AiDictationConflict
+                ? err.conflict(error.message)
+                : err.badInput(error instanceof Error ? error.message : "Recording upload failed."),
+            ),
+          );
+        }
+      })
+      .post("/conversations/:conversationId/dictations/discard", v("json", z.object({ operationId: z.uuid() })), async (c) => {
+        const ctx = await resolveContext(c);
+        if (ctx instanceof Response) return ctx;
+        const conversation = await loadConversation(c, ctx);
+        if (!conversation) return notFound(c);
+        return respond(c, ok(await aiDictations.discardOperation({
+          conversationId: conversation.id, userId: ctx.ownerUserId, operationId: c.req.valid("json").operationId,
+        })));
+      })
+      .get("/conversations/:conversationId/dictations", v("query", AiDictationListSchema), async (c) => {
+        const ctx = await resolveContext(c);
+        if (ctx instanceof Response) return ctx;
+        const conversation = await loadConversation(c, ctx);
+        if (!conversation) return notFound(c);
+        return respond(
+          c,
+          ok(await aiDictations.list({ ...c.req.valid("query"), conversationId: conversation.id, userId: ctx.ownerUserId })),
+        );
+      })
+      .get("/conversations/:conversationId/dictations/:dictationId", async (c) => {
+        const ctx = await resolveContext(c);
+        if (ctx instanceof Response) return ctx;
+        const conversation = await loadConversation(c, ctx);
+        if (!conversation) return notFound(c);
+        const result = await aiDictations.get({
+          conversationId: conversation.id,
+          userId: ctx.ownerUserId,
+          id: z.string().regex(AI_SHORT_ID_PATTERN).parse(c.req.param("dictationId")),
+        });
+        return result ? respond(c, ok(result)) : notFound(c);
+      })
+      .post("/conversations/:conversationId/dictations/:dictationId/apply", v("json", AiSaveConversationDraftInputSchema), async (c) => {
+        const ctx = await resolveContext(c);
+        if (ctx instanceof Response) return ctx;
+        const conversation = await loadConversation(c, ctx);
+        if (!conversation) return notFound(c);
+        try {
+          return respond(
+            c,
+            ok(
+              await aiDictations.apply({
+                ...c.req.valid("json"),
+                conversationId: conversation.id,
+                userId: ctx.ownerUserId,
+                id: z.string().regex(AI_SHORT_ID_PATTERN).parse(c.req.param("dictationId")),
+              }),
+            ),
+          );
+        } catch (error) {
+          return respond(
+            c,
+            fail(
+              error instanceof AiDictationConflict
+                ? err.conflict(error.message)
+                : err.badInput(error instanceof Error ? error.message : "Dictation could not be inserted."),
+            ),
+          );
+        }
+      })
+      .post(
+        "/conversations/:conversationId/dictations/:dictationId/action",
+        v("json", z.object({ action: z.enum(["discard", "retry"]) })),
+        async (c) => {
+          const ctx = await resolveContext(c);
+          if (ctx instanceof Response) return ctx;
+          const conversation = await loadConversation(c, ctx);
+          if (!conversation) return notFound(c);
+          const input = {
+            conversationId: conversation.id,
+            userId: ctx.ownerUserId,
+            id: z.string().regex(AI_SHORT_ID_PATTERN).parse(c.req.param("dictationId")),
+          };
+          if (c.req.valid("json").action === "discard") await aiDictations.discard(input);
+          else {
+            await aiDictations.retry(input);
+            await enqueueAiDictation(input.id).catch(() => undefined);
+          }
+          return respond(c, ok({ success: true }));
+        },
+      )
       .post("/conversations/:conversationId/files", async (c) => {
         const ctx = await resolveContext(c);
         if (ctx instanceof Response) return ctx;
@@ -1042,7 +1240,9 @@ export const aiRoutes = (() => {
           return respond(c, fail(err.badInput(`File exceeds the ${Math.floor(AI_FILES_MAX_FILE_BYTES_DEFAULT / (1024 * 1024))} MB limit`)));
         }
         const name = (file.name || "upload").replaceAll("/", "_").replaceAll("\\", "_").replaceAll("\0", "").slice(0, 160) || "upload";
-        const path = normalizeAiFilePath(`/${name}`);
+        const directory=form?.get("directory") ?? "/";
+        if(typeof directory!=="string")return respond(c,fail(err.badInput("Invalid directory")));
+        const path = normalizeAiFilePath(`${directory.replace(/\/$/,"")}/${name}`);
         if (!path) return respond(c, fail(err.badInput("Invalid file name")));
         if (aiProjectFilePathFromMount(path) !== null) return respond(c, fail(err.badInput("The /project namespace is reserved.")));
 
@@ -1055,6 +1255,10 @@ export const aiRoutes = (() => {
           });
           return respond(c, ok({ file: stat }));
         } catch (error) {
+          logger("ai:files").warn("Conversation upload failed", {
+            code: "file_upload_failed", conversationId: conversation.id,
+            errorType: error instanceof Error ? error.name : "unknown",
+          });
           return respond(c, fail(err.badInput(error instanceof Error ? error.message : "Upload failed")));
         }
       })

package/src/ai/run-timeout.ts

@@ -0,0 +1,10 @@
+/** Preserve why execution stopped instead of reporting an operator deadline as a user abort. */
+export class AiRunTimeout extends Error {
+  constructor(readonly budgetMs: number | null) { super("AI_RUN_TIMEOUT"); }
+  messageFor(locale?: string): string {
+    const minutes = this.budgetMs ? this.budgetMs / 60_000 : null;
+    return locale?.startsWith("de")
+      ? `Laufzeitlimit${minutes ? ` von ${minutes} Minuten` : ""} erreicht. Du kannst die Aufgabe mit einer neuen Nachricht fortsetzen.`
+      : `Run time limit${minutes ? ` of ${minutes} minutes` : ""} reached. You can continue the task with a new message.`;
+  }
+}

package/src/ai/runtime-tools.ts

@@ -1,6 +1,7 @@
 export {
   CLOUD_AI_DEFERRED_BUILTIN_TOOL_NAMES,
   createCloudAiCardTool,
+  createCloudAiCodeTools,
   createCloudAiLocalBashTool,
   createCloudAiSurveyTool,
   createCloudAiTextEditorTool,
@@ -37,3 +38,5 @@ export {
   createCloudAiMarkdownToPdfTool,
 } from "./markdown-pdf-tool";
 export { createCloudAiViewImageTool } from "./vision-tool";
+
+export { createCloudAiTranscribeAudioTool, CloudAiTranscribeAudioInputSchema, CloudAiTranscribeAudioOutputSchema } from "./audio-tool";

package/src/ai/runtime.ts

@@ -1,3 +1,8 @@
+import { parseAiResourceMarker } from "./resource-markers";
+import { aiQuotas } from "./quotas";
+import { drainQueuedMessages } from "./message-queue";
+import { coreSettings } from "../services/settings/api";
+import { startAiDictationRuntime } from "./dictation-runtime";
 import { isDeepStrictEqual } from "node:util";
 import type { InboundEvent, Input, Message } from "@k2b/nessi";
 import type { QueueMessage } from "@k2b/sync";
@@ -44,7 +49,7 @@ const AI_TURN_LEASE_MS = 45_000;
 const AI_TURN_HEARTBEAT_MS = 3_000;
 const AI_TURN_WORKER_CONCURRENCY = 8;
 const AI_TURN_MAX_ATTEMPTS = 5;
-const AI_TURN_RUN_BUDGET_MS = 10 * 60_000;
+
 const AI_SWEEP_INTERVAL_MS = 15_000;
 
 // ---------------------------------------------------------------------------
@@ -65,7 +70,14 @@ const aiTurnQueue = lazySync((sync) => {
 
 // No idempotency key: the DB claim is the only gate, so re-enqueues (recovery,
 // continuation, stale-sweep) are always allowed and never silently swallowed.
-const enqueueAiTurn = (job: AiTurnJob): Promise<unknown> => aiTurnQueue().send({ data: job, orderingKey: job.conversationId });
+const enqueueAiTurn = (job: AiTurnJob): Promise<unknown> => aiTurnQueue().send({ data: job, orderingKey: job.turnId });
+
+/** Wake the durable queue promptly; the periodic sweep retries a failed wake-up. */
+export const wakeAiMessageQueue = (conversationId: string): void => {
+  void drainQueuedMessages(enqueueAiTurn, conversationId).catch(() =>
+    log.warn("AI message queue wake-up failed", { code: "queue_wakeup_failed", conversationId }),
+  );
+};
 
 /** Enqueue a turn created atomically by another durable AI workflow. */
 export const enqueueExistingAiTurn = (input: AiTurnJob): Promise<unknown> => enqueueAiTurn(input);
@@ -103,7 +115,7 @@ export type SubmitAiChatTurnInput = {
   retrySourceTurnId?: string;
 };
 
-export const submitAiChatTurn = async (input: SubmitAiChatTurnInput): Promise<{ turn: AiTurn; message: AiStoredMessage }> => {
+export const prepareAiChatTurn = async (input: SubmitAiChatTurnInput) => {
   if (input.clientToolIds?.length && input.toolSource?.kind !== "default") {
     throw new Error("Optional client tools require the default tool source.");
   }
@@ -128,8 +140,14 @@ export const submitAiChatTurn = async (input: SubmitAiChatTurnInput): Promise<{
     modelPolicy: input.modelPolicy,
     requestedModelId,
   });
+  const quotaSubject = aiChatAccessSubject(input.actor);
+  if (input.assistantChat && quotaSubject) await aiQuotas.assertAllowed(quotaSubject, resolved.profile.id);
   const runConfig: AiChatTurnRunConfig = {
     kind: "chat",
+    selectedSkillIds: [...new Set((userMessage.role === "user" ? userMessage.content : []).flatMap(part => {
+      const marker = parseAiResourceMarker(typeof part === "string" ? part : part.type === "text" ? part.text : "");
+      return marker?.ref.type === "core.ai.skill" ? [marker.ref.id] : [];
+    }))],
     ...(input.assistantChat ? { assistantChat: true } : {}),
     input: canonicalInput,
     chatId: input.chatId,
@@ -146,7 +164,7 @@ export const submitAiChatTurn = async (input: SubmitAiChatTurnInput): Promise<{
     toolApprovalContext: input.toolApprovalContext,
   };
 
-  const submitted = await aiConversations.submitChatTurn({
+  return {
     conversationId: input.conversationId,
     modelProfileId: resolved.profile.id,
     runConfig,
@@ -156,8 +174,11 @@ export const submitAiChatTurn = async (input: SubmitAiChatTurnInput): Promise<{
     expectedProjectId: input.expectedProjectId,
     resources: input.resources,
     retrySourceTurnId: input.retrySourceTurnId,
-  });
+  };
+};
 
+export const submitAiChatTurn = async (input: SubmitAiChatTurnInput): Promise<{ turn: AiTurn; message: AiStoredMessage }> => {
+  const submitted = await aiConversations.submitChatTurn(await prepareAiChatTurn(input));
   await enqueueAiTurn({ conversationId: input.conversationId, turnId: submitted.turn.id });
   return submitted;
 };
@@ -242,7 +263,8 @@ export const abortAiTurn = async (input: { conversationId: string; turnId: strin
 
   if (request.ownerless) {
     const finalized = await aiConversations.completeTurn({ ...input, status: "aborted", error: null });
-    if (finalized === "completed") {
+    const config = await aiConversations.getTurnRunConfig(input);
+    if (finalized === "completed" && !(config?.kind === "chat" && config.background)) {
       const attempt = active?.turn.id === input.turnId ? active.turn.attempt : 1;
       const seq = (active?.turn.id === input.turnId ? active.liveSeq : 0) + 1;
       await publishAiWireEvent({
@@ -343,9 +365,7 @@ export const submitAiTurnAction = async (input: {
         return { ok: false, status: 409, message: "AI action was already resolved with a different response." };
       }
     }
-    await aiToolAudit
-      .noteToolCompleted({ turnId: input.turnId, callId: input.callId, result: input.action.result, isError: false })
-      .catch(() => undefined);
+    await aiToolAudit.noteToolCompleted({ turnId: input.turnId, callId: input.callId, isError: false }).catch(() => undefined);
   }
 
   await enqueueAiTurn({ conversationId: input.conversationId, turnId: input.turnId });
@@ -362,6 +382,8 @@ const runClaimedTurn = async (
   leaseOwner: string,
   onTurnFinalized?: (event: AiTurnFinalizedEvent) => Promise<void>,
 ): Promise<void> => {
+  const timeoutMinutes = await coreSettings.get<number>("ai.turn_timeout_minutes");
+  const runBudgetMs = Math.max(0, Number(timeoutMinutes ?? 30)) * 60_000;
   const claim =
     (await aiConversations.claimTurn({
       ...job,
@@ -369,7 +391,7 @@ const runClaimedTurn = async (
       leaseMs: AI_TURN_LEASE_MS,
       from: "queue",
       maxAttempts: AI_TURN_MAX_ATTEMPTS,
-      runBudgetMs: AI_TURN_RUN_BUDGET_MS,
+      runBudgetMs,
     })) ??
     (await aiConversations.claimTurn({
       ...job,
@@ -377,7 +399,7 @@ const runClaimedTurn = async (
       leaseMs: AI_TURN_LEASE_MS,
       from: "waiting",
       maxAttempts: AI_TURN_MAX_ATTEMPTS,
-      runBudgetMs: AI_TURN_RUN_BUDGET_MS,
+      runBudgetMs,
     }));
 
   if (!claim) return; // Already owned, done, cancelled, or attempt-capped.
@@ -392,12 +414,22 @@ const runClaimedTurn = async (
 };
 
 const processMessage = async (
-  message: QueueMessage<AiTurnJob>,
+  message: Pick<QueueMessage<AiTurnJob>, "messageId" | "data" | "heartbeat">,
   signal: AbortSignal,
   onTurnFinalized?: (event: AiTurnFinalizedEvent) => Promise<void>,
 ): Promise<void> => {
   const leaseOwner = `${AI_WORKER_ID}:${message.messageId}:${crypto.randomUUID()}`;
-  const touch = setInterval(() => void message.heartbeat().catch(() => undefined), AI_TURN_HEARTBEAT_MS);
+  let heartbeatFailed = false;
+  const touch = setInterval(() => {
+    void message.heartbeat().then(() => { heartbeatFailed = false; }).catch(() => {
+      if (!heartbeatFailed && !signal.aborted) {
+        log.warn("AI queue heartbeat failed", {
+          code: "queue_heartbeat_failed", conversationId: message.data.conversationId, turnId: message.data.turnId,
+        });
+      }
+      heartbeatFailed = true;
+    });
+  }, AI_TURN_HEARTBEAT_MS);
   if (typeof touch === "object" && "unref" in touch) touch.unref();
   try {
     await runClaimedTurn(message.data, signal, leaseOwner, onTurnFinalized);
@@ -409,10 +441,13 @@ const processMessage = async (
     });
   } finally {
     clearInterval(touch);
+    if (!signal.aborted) wakeAiMessageQueue(message.data.conversationId);
   }
 };
 
 const publishSweepFinished = async (turn: AiTurnFinalizedAction & { error?: string }, status: "failed" | "aborted"): Promise<void> => {
+  const config = await aiConversations.getTurnRunConfig(turn);
+  if (config?.kind === "chat" && config.background) return;
   await publishAiWireEvent({
     v: 1,
     conversationId: turn.conversationId,
@@ -422,13 +457,15 @@ const publishSweepFinished = async (turn: AiTurnFinalizedAction & { error?: stri
     type: "turn_finished",
     status,
     error: status === "failed" ? (turn.error ?? "AI turn failed.") : null,
-  }).catch(() => undefined);
+  }).catch(() => log.warn("AI completion notification failed", {code:"completion_publish_failed",conversationId:turn.conversationId,turnId:turn.turnId}));
 };
 
 export const sweepAiRuntime = async (onTurnFinalized?: (event: AiTurnFinalizedEvent) => Promise<void>): Promise<void> => {
+  await aiQuotas.prune().catch(() => log.warn("Quota retention failed", { code: "quota_retention_failed" }));
+  await drainQueuedMessages(enqueueAiTurn);
   const sweep = await aiConversations.sweepTurns({ maxAttempts: AI_TURN_MAX_ATTEMPTS });
   await Promise.all([
-    ...sweep.requeued.map((job) => enqueueAiTurn(job).catch(() => undefined)),
+    ...sweep.requeued.map((job) => enqueueAiTurn(job).catch(() => log.warn("AI recovery enqueue failed", {code:"recovery_enqueue_failed",...job}))),
     ...sweep.failed.map((turn) => publishSweepFinished(turn, "failed")),
     ...sweep.aborted.map((turn) => publishSweepFinished(turn, "aborted")),
   ]);
@@ -508,11 +545,13 @@ export const startAiRuntime = (
   const sweepTimer = setInterval(runSweep, AI_SWEEP_INTERVAL_MS);
   if (typeof sweepTimer === "object" && "unref" in sweepTimer) sweepTimer.unref();
 
+  const stopDictations = startAiDictationRuntime();
   const state: AiRuntimeState = {
     listeners,
     stop: () => {
       if (running !== state) return;
       controller.abort();
+      stopDictations();
       clearInterval(sweepTimer);
       listeners.clear();
       running = null;
@@ -541,4 +580,4 @@ const releaseAiRuntime = (listener: ((event: AiTurnFinalizedEvent) => Promise<vo
   };
 };
 
-export const __aiRuntimeTest = { actionMatchesResolvedEvent };
+export const __aiRuntimeTest = { actionMatchesResolvedEvent, processMessage, publishSweepFinished };