@k2b/cloud 0.6.0 → 0.8.0

package/src/ai/store.ts

@@ -1,11 +1,12 @@
 import type { DoneReason, InboundEvent, LoopAggregate, Message, SessionStore, StoreEntry } from "@k2b/nessi";
 import type { Usage } from "@k2b/nessi/ai";
-import { sql } from "bun";
+import { type SQL, sql } from "bun";
 import { type CapabilityActionReview, CapabilityActionReviewSchema } from "../contracts/capabilities";
 import { logger } from "../services/logging";
 import { toPgTextArray } from "../services/postgres";
 import type { AiTurnBlock } from "./protocol";
 import { withAiShortId, withAiShortIdForDb } from "./short-id";
+import { parseAiTodoPlan } from "./todo-contracts";
 import type {
   AiConversation,
   AiConversationDraft,
@@ -89,6 +90,7 @@ const isSearchCapabilityError = (error: unknown): boolean =>
   typeof error === "object" && error !== null && "code" in error && SEARCH_CAPABILITY_ERROR_CODES.has(String(error.code));
 
 type ConversationRow = {
+  activity?: AiConversation["activity"];
   id: string;
   short_id: string;
   title: string;
@@ -98,8 +100,14 @@ type ConversationRow = {
   keywords: string[] | null;
   pinned_at: Date | string | null;
   archived_at: Date | string | null;
+  done: boolean | null;
+  last_used_at: Date | string;
+  is_done?: boolean;
+  has_active_schedule?: boolean;
+  background_received_at?: Date | string | null;
   last_viewed_at: Date | string | null;
   latest_turn_status?: AiTurnStatus | null;
+  latest_browser_pending?: boolean;
   latest_turn_error?: string | null;
   latest_turn_completed_at?: Date | string | null;
   enrich_fail_count: number | null;
@@ -157,6 +165,9 @@ type MessageRow = {
 };
 
 type TurnRow = {
+  deadline?: Date | string | null;
+  run_budget_ms?: number | null;
+  cancel_requested_at?: Date | string | null;
   id: string;
   short_id: string;
   conversation_id: string;
@@ -360,7 +371,7 @@ const rowToInterChatMessage = (row: InterChatMessageRow): AiInterChatMessage =>
   deliveredAt: row.delivered_at ? iso(row.delivered_at) : null,
 });
 
-const interChatMessageSelect = sql`
+const interChatMessageSelect = () => sql`
   SELECT message.id, message.short_id, message.source_conversation_id,
          source.short_id AS source_chat_id, source.title AS source_title,
          message.source_turn_id, source_turn.short_id AS source_turn_short_id, message.source_call_id,
@@ -470,16 +481,55 @@ const parseCapabilityActionReview = (value: unknown): CapabilityActionReview | u
 
 const fieldSource = (value: string | null): AiConversation["titleSource"] => (value === "auto" || value === "user" ? value : "default");
 
-const conversationRunStatus = (status: AiTurnStatus | null | undefined): AiConversation["runStatus"] => {
+// Pins stay active; otherwise explicit choices win and automatic completion never hides pending work.
+const effectiveDone = () => sql`(conversation.pinned_at IS NULL AND COALESCE(conversation.done,
+  conversation.last_used_at <= now() - interval '7 days'
+  AND NOT EXISTS (SELECT 1 FROM ai.chat_tasks schedule WHERE schedule.conversation_id = conversation.id AND schedule.state = 'active')
+  AND NOT EXISTS (SELECT 1 FROM ai.turns active_turn
+    WHERE active_turn.conversation_id = conversation.id
+      AND NOT COALESCE(active_turn.run_config ? 'background', false)
+      AND active_turn.status IN ('queued', 'running', 'waiting_for_action'))
+  AND NOT EXISTS (SELECT 1 FROM ai.queued_messages pending WHERE pending.conversation_id = conversation.id AND pending.status IN ('pending','failed'))))`;
+
+const browserWorkPending = () => sql`(
+  latest.status = 'waiting_for_action'
+  AND EXISTS (
+    SELECT 1 FROM jsonb_array_elements(CASE WHEN jsonb_typeof(latest.live_blocks) = 'array' THEN latest.live_blocks ELSE '[]'::jsonb END) block
+    WHERE block->>'kind' = 'tool' AND block->>'status' = 'awaiting_client' AND block->>'frontendMode' = 'client'
+  )
+  AND NOT EXISTS (
+    SELECT 1 FROM jsonb_array_elements(CASE WHEN jsonb_typeof(latest.live_blocks) = 'array' THEN latest.live_blocks ELSE '[]'::jsonb END) block
+    WHERE block->>'kind' = 'tool' AND (
+      block->>'status' = 'awaiting_approval'
+      OR (block->>'status' = 'awaiting_client' AND COALESCE(block->>'frontendMode', '') <> 'client')
+    )
+  )
+)`;
+
+const conversationRunStatus = (status: AiTurnStatus | null | undefined, browserPending = false): AiConversation["runStatus"] => {
   if (status === "queued") return "queued";
   if (status === "running") return "running";
-  if (status === "waiting_for_action") return "needs_attention";
+  if (status === "waiting_for_action") return browserPending ? "waiting_for_browser" : "needs_attention";
   if (status === "failed") return "failed";
   return "idle";
 };
 
+// Bun SQL may return historical JSON payloads as string-encoded JSON.
+const todoMessageJson = () => sql`(CASE WHEN jsonb_typeof(message) = 'string' THEN (message #>> '{}')::jsonb ELSE message END)`;
+const todoMetaJson = () => sql`(CASE WHEN jsonb_typeof(meta) = 'string' THEN (meta #>> '{}')::jsonb ELSE meta END)`;
+
+// A scheduled result arriving during an interactive turn becomes context on the next turn.
+const visibleToTurn = (turnId?: string) => sql`(
+  ${turnId ?? null}::text IS NULL OR NOT COALESCE(meta ? 'scheduledTask', false) OR seq < ALL (
+    SELECT input_message.seq FROM ai.messages input_message
+    WHERE input_message.loop_id = ${turnId ?? null} AND input_message.role = 'user'
+  )
+)`;
+
 const rowToConversation = (row: ConversationRow): AiConversation => ({
+  ...(row.activity ? { activity: row.activity } : {}),
   id: row.id,
+  hasActiveSchedule: Boolean(row.has_active_schedule),
   shortId: row.short_id,
   title: row.title,
   titleSource: fieldSource(row.title_source),
@@ -488,12 +538,25 @@ const rowToConversation = (row: ConversationRow): AiConversation => ({
   keywords: row.keywords ?? [],
   pinnedAt: row.pinned_at ? iso(row.pinned_at) : null,
   archivedAt: row.archived_at ? iso(row.archived_at) : null,
-  runStatus: conversationRunStatus(row.latest_turn_status),
+  done: row.done,
+  isDone: row.pinned_at
+    ? false
+    : (row.is_done ??
+      row.done ??
+      (new Date(row.last_used_at).getTime() <= Date.now() - 7 * 86400000 &&
+        !row.has_active_schedule &&
+        !["queued", "running", "waiting_for_action"].includes(row.latest_turn_status ?? ""))),
+  lastUsedAt: iso(row.last_used_at),
+  runStatus: conversationRunStatus(row.latest_turn_status, row.latest_browser_pending),
   runError: row.latest_turn_status === "failed" ? row.latest_turn_error?.trim() || "Assistant response failed." : null,
   unreadCompletion:
-    row.latest_turn_status === "completed" &&
-    Boolean(row.latest_turn_completed_at) &&
-    (!row.last_viewed_at || new Date(row.latest_turn_completed_at!).getTime() > new Date(row.last_viewed_at).getTime()),
+    Boolean(
+      row.background_received_at &&
+        (!row.last_viewed_at || new Date(row.background_received_at).getTime() > new Date(row.last_viewed_at).getTime()),
+    ) ||
+    (row.latest_turn_status === "completed" &&
+      Boolean(row.latest_turn_completed_at) &&
+      (!row.last_viewed_at || new Date(row.latest_turn_completed_at!).getTime() > new Date(row.last_viewed_at).getTime())),
   projectId: row.project_id,
   draft: {
     content: parseJsonValue<AiConversationDraft["content"]>(row.draft_content ?? []),
@@ -566,6 +629,9 @@ const rowToMessage = (row: MessageRow): AiStoredMessage => {
 };
 
 const rowToTurn = (row: TurnRow): AiTurn => ({
+  deadline: row.deadline ? iso(row.deadline) : null,
+  runBudgetMs: row.run_budget_ms ?? null,
+  cancelRequestedAt: row.cancel_requested_at ? iso(row.cancel_requested_at) : null,
   id: row.id,
   shortId: row.short_id,
   conversationId: row.conversation_id,
@@ -591,7 +657,7 @@ const pendingActionToPublicEvent = (row: PendingActionRow): AiPendingTurnAction
         conversationId: row.conversation_id,
         callId: row.call_id,
         name: row.tool_name,
-        args: parseJsonValue(row.args),
+        args: row.args,
         mode: row.frontend_mode ?? "client",
       }
     : {
@@ -600,7 +666,7 @@ const pendingActionToPublicEvent = (row: PendingActionRow): AiPendingTurnAction
         conversationId: row.conversation_id,
         callId: row.call_id,
         name: row.tool_name,
-        args: parseJsonValue(row.args),
+        args: row.args,
         message: row.message ?? undefined,
         review: parseCapabilityActionReview(row.review),
         allowAlways: row.allow_always,
@@ -613,7 +679,7 @@ const rowToPendingActionRecord = (row: PendingActionRow): AiPendingTurnActionRec
   kind: row.kind,
   status: row.status,
   name: row.tool_name,
-  args: parseJsonValue(row.args),
+  args: row.args,
   message: row.message ?? undefined,
   review: parseCapabilityActionReview(row.review),
   approvalScope: row.approval_scope,
@@ -649,14 +715,17 @@ const loadConversationSummary = async (input: {
   const rows = await sql<ConversationRow[]>`
     SELECT
       conversation.*,
+      ${effectiveDone()} AS is_done,
+        EXISTS (SELECT 1 FROM ai.chat_tasks schedule WHERE schedule.conversation_id = conversation.id AND schedule.state = 'active') AS has_active_schedule,
       latest.status AS latest_turn_status,
+      ${browserWorkPending()} AS latest_browser_pending,
       latest.error AS latest_turn_error,
       latest.completed_at AS latest_turn_completed_at
     FROM ai.conversations conversation
     LEFT JOIN LATERAL (
-      SELECT status, error, completed_at
+      SELECT status, error, completed_at, live_blocks
       FROM ai.turns
-      WHERE conversation_id = conversation.id
+      WHERE conversation_id = conversation.id AND NOT COALESCE(run_config ? 'background', false)
       ORDER BY created_at DESC, id DESC
       LIMIT 1
     ) latest ON TRUE
@@ -666,7 +735,15 @@ const loadConversationSummary = async (input: {
       AND (${Boolean(input.archived)}::boolean = (conversation.archived_at IS NOT NULL))
     LIMIT 1
   `;
-  return rows[0] ? rowToConversation(rows[0]) : null;
+  if (!rows[0]) return null;
+  const plans = await sql<{ seq: number; plan: unknown }[]>`
+    SELECT seq, CASE WHEN role = 'tool_result' THEN ${todoMessageJson()}->'result' ELSE ${todoMetaJson()}->'todoPlan' END AS plan
+    FROM ai.messages WHERE conversation_id = ${rows[0].id}
+      AND ((role = 'tool_result' AND ${todoMessageJson()}->>'name' = 'todo_write' AND COALESCE(${todoMessageJson()}->>'isError','false') = 'false') OR ${todoMetaJson()} ? 'todoPlan')
+    ORDER BY seq DESC, id DESC LIMIT 1
+  `;
+  const plan = parseAiTodoPlan(plans[0]?.plan);
+  return { ...rowToConversation(rows[0]), ...(plan ? { todoPlan: { seq: Number(plans[0]!.seq), todos: plan.todos } } : {}) };
 };
 
 const firstText = (message: Message): string => {
@@ -745,14 +822,14 @@ const insertMessageLocked = async (
       ${seq},
       ${input.kind ?? "message"},
       ${input.message.role},
-      ${JSON.stringify(input.message)}::jsonb,
+      ${JSON.stringify(input.message)}::text::jsonb,
       ${messageSearchText(input.message)},
       ${input.loopId ?? null},
       ${input.modelProfileId ?? null},
       ${providerModel},
-      ${usage ? JSON.stringify(usage) : null}::jsonb,
+      ${usage ? JSON.stringify(usage) : null}::text::jsonb,
       ${stopReason},
-      ${input.meta ? JSON.stringify(input.meta) : null}::jsonb
+      ${input.meta ? JSON.stringify(input.meta) : null}::text::jsonb
     )
     RETURNING *
   `,
@@ -776,6 +853,7 @@ const insertMessageLocked = async (
 
 /** Append a turn-owned (assistant/tool_result/summary) message, guarded by lease ownership in one statement. */
 const appendTurnOwnedMessage = async (input: {
+  background?: boolean;
   conversationId: string;
   turnId: string;
   leaseOwner: string;
@@ -785,12 +863,15 @@ const appendTurnOwnedMessage = async (input: {
   loopId: string | null;
   modelProfileId?: string | null;
   meta?: AiStoredMessage["meta"];
-}): Promise<boolean> => {
-  const { usage, providerModel, stopReason } = messageColumns(input.message);
-  const rows = await withAiShortId(
-    "idx_ai_messages_conversation_short_id",
-    (shortId) => sql<{ id: string }[]>`
-    INSERT INTO ai.messages (
+}): Promise<AiStoredMessage | null> => {
+  return sql.begin(async (tx) => {
+    if (!input.background) await tx`SELECT id FROM ai.conversations WHERE id = ${input.conversationId}::uuid FOR UPDATE`;
+    const { usage, providerModel, stopReason } = messageColumns(input.message);
+    const rows = await withAiShortIdForDb(
+      tx,
+      "idx_ai_messages_conversation_short_id",
+      (attempt, shortId) => attempt<MessageRow[]>`
+    INSERT INTO ${sql(input.background ? "ai.task_messages" : "ai.messages")} (
       short_id,
       conversation_id,
       seq,
@@ -808,18 +889,18 @@ const appendTurnOwnedMessage = async (input: {
       ${shortId},
       ${input.conversationId},
       CASE
-        WHEN ${input.seq ?? null}::int IS NOT NULL AND ${input.seq ?? null}::int > 0 THEN ${input.seq ?? null}::int
-        ELSE (SELECT COALESCE(MAX(seq), 0) + 1 FROM ai.messages WHERE conversation_id = ${input.conversationId} AND seq > 0)
+        WHEN NOT ${Boolean(input.background)} AND ${input.kind === "summary"} AND ${input.seq ?? null}::int IS NOT NULL AND ${input.seq ?? null}::int > 0 THEN ${input.seq ?? null}::int
+        ELSE (SELECT COALESCE(MAX(seq), 0) + 1 FROM ${sql(input.background ? "ai.task_messages" : "ai.messages")} WHERE conversation_id = ${input.conversationId} AND seq > 0 AND (NOT ${Boolean(input.background)} OR loop_id = ${input.turnId}))
       END,
       ${input.kind ?? "message"},
       ${input.message.role},
-      ${JSON.stringify(input.message)}::jsonb,
+      ${JSON.stringify(input.message)}::text::jsonb,
       ${input.loopId},
       ${input.modelProfileId ?? null},
       ${providerModel},
-      ${usage ? JSON.stringify(usage) : null}::jsonb,
+      ${usage ? JSON.stringify(usage) : null}::text::jsonb,
       ${stopReason},
-      ${input.meta ? JSON.stringify(input.meta) : null}::jsonb
+      ${input.meta ? JSON.stringify(input.meta) : null}::text::jsonb
     WHERE EXISTS (
       SELECT 1
       FROM ai.turns
@@ -828,14 +909,15 @@ const appendTurnOwnedMessage = async (input: {
         AND status IN ('running', 'waiting_for_action')
         AND lease_owner = ${input.leaseOwner}
     )
-    RETURNING id
+    RETURNING *
   `,
-  );
-  if (rows[0]) {
-    await sql`UPDATE ai.conversations SET updated_at = now() WHERE id = ${input.conversationId}`;
-    return true;
-  }
-  return false;
+    );
+    if (rows[0]) {
+      if (!input.background) await tx`UPDATE ai.conversations SET updated_at = now() WHERE id = ${input.conversationId}`;
+      return rowToMessage(rows[0]);
+    }
+    return null;
+  });
 };
 
 const toolMessageMeta = (
@@ -857,6 +939,69 @@ const toolMessageMeta = (
   return Object.keys(toolPresentations).length > 0 ? { toolPresentations } : null;
 };
 
+export const saveAiDraftInTransaction = async (
+  tx: SQL,
+  input: Parameters<AiConversationService["saveDraft"]>[0],
+): ReturnType<AiConversationService["saveDraft"]> => {
+  const [conversation] = await tx<{ draft_content: unknown; draft_revision: number | string; draft_updated_at: Date | string | null }[]>`
+        SELECT draft_content, draft_revision, draft_updated_at
+        FROM ai.conversations
+        WHERE id = ${input.conversationId}::uuid
+          AND created_by_user_id = ${input.ownerUserId}::uuid
+          AND archived_at IS NULL
+        FOR UPDATE
+      `;
+  if (!conversation) return { ok: false as const, reason: "not_found" as const };
+  if (Number(conversation.draft_revision) !== input.expectedRevision) {
+    return { ok: false as const, reason: "conflict" as const };
+  }
+  const [sameDraft] = await tx<{ same: boolean }[]>`
+        SELECT ${JSON.stringify(input.content)}::text::jsonb = ${JSON.stringify(parseJsonValue(conversation.draft_content))}::text::jsonb AS same
+      `;
+  if (sameDraft?.same) {
+    return {
+      ok: true as const,
+      draft: {
+        content: input.content,
+        revision: Number(conversation.draft_revision),
+        updatedAt: conversation.draft_updated_at ? iso(conversation.draft_updated_at) : null,
+      },
+    };
+  }
+
+  for (const part of input.content) {
+    if (part.type !== "file") continue;
+    const [file] = await tx<{ exists: boolean }[]>`
+          SELECT EXISTS (
+            SELECT 1 FROM ai.files
+            WHERE conversation_id = ${input.conversationId}::uuid
+              AND path = ${part.path}
+              AND media_type = ${part.mediaType}
+              AND size = ${part.size}
+              AND version = ${part.version}
+          ) AS exists
+        `;
+    if (!file?.exists) throw new Error(`Conversation file changed or no longer exists: ${part.path}`);
+  }
+
+  const [saved] = await tx<{ draft_content: unknown; draft_revision: number | string; draft_updated_at: Date | string }[]>`
+        UPDATE ai.conversations
+        SET draft_content = ${JSON.stringify(input.content)}::text::jsonb,
+            draft_revision = draft_revision + 1,
+            draft_updated_at = now()
+        WHERE id = ${input.conversationId}::uuid
+        RETURNING draft_content, draft_revision, draft_updated_at
+      `;
+  return {
+    ok: true as const,
+    draft: {
+      content: parseJsonValue<AiConversationDraft["content"]>(saved!.draft_content),
+      revision: Number(saved!.draft_revision),
+      updatedAt: iso(saved!.draft_updated_at),
+    },
+  };
+};
+
 export const aiConversations: AiConversationService = {
   createConversation: async (input) => {
     const rows = await withAiShortId(
@@ -880,7 +1025,7 @@ export const aiConversations: AiConversationService = {
         ${input.title?.trim() || "New chat"},
         ${input.description?.trim() ?? ""},
         ${input.projectId ?? null}::uuid,
-        ${JSON.stringify(input.draft ?? [])}::jsonb,
+        ${JSON.stringify(input.draft ?? [])}::text::jsonb,
         ${input.draft?.length ? 1 : 0},
         ${toPgTextArray(input.preloadTools ?? [])}::text[],
         ${input.draft?.length ? new Date() : null},
@@ -920,11 +1065,12 @@ export const aiConversations: AiConversationService = {
       await tx`
         INSERT INTO ai.messages (
           short_id, conversation_id, seq, kind, role, message, search_text, loop_id,
-          model_profile_id, provider_model, usage, stop_reason, loop_aggregate, loop_done_reason
+          model_profile_id, provider_model, usage, stop_reason, loop_aggregate, loop_done_reason, meta
         )
         SELECT
           short_id, ${target.id}::uuid, seq, kind, role, message, search_text, loop_id,
-          model_profile_id, provider_model, usage, stop_reason, loop_aggregate, loop_done_reason
+          model_profile_id, provider_model, usage, stop_reason, loop_aggregate, loop_done_reason,
+          CASE WHEN ${todoMetaJson()} ? 'todoPlan' THEN jsonb_build_object('todoPlan', ${todoMetaJson()}->'todoPlan') ELSE NULL END
         FROM ai.messages
         WHERE conversation_id = ${input.sourceConversationId}::uuid
           AND compacted_at IS NULL
@@ -932,8 +1078,8 @@ export const aiConversations: AiConversationService = {
         ORDER BY seq ASC
       `;
       await tx`
-        INSERT INTO ai.files (conversation_id, path, bytes, media_type, size, origin, updated_at)
-        SELECT ${target.id}::uuid, path, bytes, media_type, size, origin, updated_at
+        INSERT INTO ai.files (conversation_id, path, bytes, media_type, size, origin, dictation_recorded_at, updated_at, version)
+        SELECT ${target.id}::uuid, path, bytes, media_type, size, origin, dictation_recorded_at, updated_at, version
         FROM ai.files WHERE conversation_id = ${input.sourceConversationId}::uuid
       `;
       return rowToConversation(target);
@@ -950,23 +1096,29 @@ export const aiConversations: AiConversationService = {
     const rows = await withConversationSearchBackend(query, async (backend) => {
       const order = query
         ? sql`${conversationSearchRank(backend, query)} DESC, conversation.pinned_at DESC NULLS LAST, conversation.updated_at DESC, conversation.created_at DESC`
-        : sql`conversation.pinned_at DESC NULLS LAST, conversation.updated_at DESC, conversation.created_at DESC`;
+        : input.done === true
+          ? sql`conversation.last_used_at DESC, conversation.id DESC`
+          : sql`conversation.pinned_at DESC NULLS LAST, conversation.updated_at DESC, conversation.created_at DESC`;
       return sql<ConversationRow[]>`
       SELECT
         conversation.*,
+        ${effectiveDone()} AS is_done,
+        EXISTS (SELECT 1 FROM ai.chat_tasks schedule WHERE schedule.conversation_id = conversation.id AND schedule.state = 'active') AS has_active_schedule,
         latest.status AS latest_turn_status,
+        ${browserWorkPending()} AS latest_browser_pending,
         latest.error AS latest_turn_error,
         latest.completed_at AS latest_turn_completed_at
       FROM ai.conversations conversation
       LEFT JOIN LATERAL (
-        SELECT status, error, completed_at
+        SELECT status, error, completed_at, live_blocks
         FROM ai.turns
-        WHERE conversation_id = conversation.id
+        WHERE NOT COALESCE(run_config ? 'background', false) AND conversation_id = conversation.id
         ORDER BY created_at DESC, id DESC
         LIMIT 1
       ) latest ON TRUE
       WHERE conversation.created_by_user_id = ${input.ownerUserId}
         AND (${archived}::boolean = (conversation.archived_at IS NOT NULL))
+        AND (${input.done ?? null}::boolean IS NULL OR ${input.done ?? null}::boolean = ${effectiveDone()})
         AND (${input.projectId ?? null}::uuid IS NULL OR conversation.project_id = ${input.projectId ?? null}::uuid)
         AND (NOT ${Boolean(input.unassigned)}::boolean OR conversation.project_id IS NULL)
         AND (${refs.length === 0}::boolean OR NOT EXISTS (
@@ -993,10 +1145,12 @@ export const aiConversations: AiConversationService = {
                 OR message.search_document @@ websearch_to_tsquery('simple', ${query ?? ""}))
           ))
         AND (${status}::text IS NULL
-          OR (${status} = 'running' AND latest.status IN ('queued', 'running'))
-          OR (${status} = 'needs_attention' AND latest.status = 'waiting_for_action')
+          OR (${status} = 'running' AND (latest.status IN ('queued', 'running') OR ${browserWorkPending()}))
+          OR (${status} = 'needs_attention' AND latest.status = 'waiting_for_action' AND NOT ${browserWorkPending()})
           OR (${status} = 'failed' AND latest.status = 'failed')
-          OR (${status} = 'unread' AND latest.status = 'completed' AND latest.completed_at > COALESCE(conversation.last_viewed_at, '-infinity')))
+          OR (${status} = 'unread' AND (
+            (latest.status = 'completed' AND latest.completed_at > COALESCE(conversation.last_viewed_at, '-infinity'))
+            OR conversation.background_received_at > COALESCE(conversation.last_viewed_at, '-infinity'))))
       ORDER BY ${order}
       LIMIT ${limit}
     `;
@@ -1005,35 +1159,33 @@ export const aiConversations: AiConversationService = {
   },
 
   listSidebarConversations: async (input) => {
-    const unassignedLimit = Math.min(Math.max(input.unassignedLimit ?? 15, 1), 50);
-    const perProjectLimit = Math.min(Math.max(input.perProjectLimit ?? 10, 1), 50);
     const rows = await sql<ConversationRow[]>`
-      WITH ranked AS (
-        SELECT
-          conversation.*,
-          latest.status AS latest_turn_status,
-          latest.error AS latest_turn_error,
-          latest.completed_at AS latest_turn_completed_at,
-          row_number() OVER (
-            PARTITION BY conversation.project_id
-            ORDER BY conversation.pinned_at DESC NULLS LAST, conversation.updated_at DESC, conversation.created_at DESC, conversation.id
-          ) AS sidebar_rank
-        FROM ai.conversations conversation
-        LEFT JOIN LATERAL (
-          SELECT status, error, completed_at
-          FROM ai.turns
-          WHERE conversation_id = conversation.id
-          ORDER BY created_at DESC, id DESC
-          LIMIT 1
-        ) latest ON TRUE
-        WHERE conversation.created_by_user_id = ${input.ownerUserId}::uuid
-          AND conversation.archived_at IS NULL
-      )
-      SELECT *
-      FROM ranked
-      WHERE (project_id IS NULL AND sidebar_rank <= ${unassignedLimit})
-         OR (project_id IS NOT NULL AND sidebar_rank <= ${perProjectLimit})
-      ORDER BY pinned_at DESC NULLS LAST, updated_at DESC, created_at DESC, id
+      SELECT conversation.*, ${effectiveDone()} AS is_done,
+        EXISTS (SELECT 1 FROM ai.chat_tasks schedule WHERE schedule.conversation_id = conversation.id AND schedule.state = 'active') AS has_active_schedule,
+        latest.status AS latest_turn_status, ${browserWorkPending()} AS latest_browser_pending,
+        latest.error AS latest_turn_error, latest.completed_at AS latest_turn_completed_at,
+        jsonb_build_object('completed', COALESCE(progress.completed,0), 'total', COALESCE(progress.total,0),
+          'step', progress.step, 'tool', ai.sidebar_tool_label(latest.live_blocks)->>'label') AS activity
+      FROM ai.conversations conversation
+      LEFT JOIN LATERAL (
+        SELECT status, error, completed_at, live_blocks FROM ai.turns
+        WHERE NOT COALESCE(run_config ? 'background', false) AND conversation_id = conversation.id ORDER BY created_at DESC, id DESC LIMIT 1
+      ) latest ON TRUE
+      LEFT JOIN LATERAL (
+        SELECT CASE WHEN role = 'tool_result' THEN ${todoMessageJson()}->'result' ELSE ${todoMetaJson()}->'todoPlan' END AS plan
+        FROM ai.messages WHERE conversation_id = conversation.id
+          AND ((role = 'tool_result' AND ${todoMessageJson()}->>'name' = 'todo_write' AND COALESCE(${todoMessageJson()}->>'isError','false') = 'false') OR ${todoMetaJson()} ? 'todoPlan')
+        ORDER BY seq DESC, id DESC LIMIT 1
+      ) working ON TRUE
+      LEFT JOIN LATERAL (
+        SELECT count(*) FILTER (WHERE task->>'status' = 'completed')::int AS completed,
+          count(*) FILTER (WHERE task->>'status' <> 'cancelled')::int AS total,
+          max(task->>'content') FILTER (WHERE task->>'status' = 'in_progress') AS step
+        FROM jsonb_array_elements(CASE WHEN jsonb_typeof(working.plan->'todos') = 'array' THEN working.plan->'todos' ELSE '[]'::jsonb END) task
+      ) progress ON TRUE
+      WHERE conversation.created_by_user_id = ${input.ownerUserId}::uuid
+        AND conversation.archived_at IS NULL AND NOT ${effectiveDone()}
+      ORDER BY conversation.pinned_at DESC NULLS LAST, conversation.last_used_at DESC, conversation.id
     `;
     return rows.map(rowToConversation);
   },
@@ -1047,23 +1199,29 @@ export const aiConversations: AiConversationService = {
     const rows = await withConversationSearchBackend(query, async (backend) => {
       const order = query
         ? sql`${conversationSearchRank(backend, query)} DESC, conversation.pinned_at DESC NULLS LAST, conversation.updated_at DESC, conversation.created_at DESC`
-        : sql`conversation.pinned_at DESC NULLS LAST, conversation.updated_at DESC, conversation.created_at DESC`;
+        : input.done === true
+          ? sql`conversation.last_used_at DESC, conversation.id DESC`
+          : sql`conversation.pinned_at DESC NULLS LAST, conversation.updated_at DESC, conversation.created_at DESC`;
       return sql<ConversationRow[]>`
       SELECT
         conversation.*,
+        ${effectiveDone()} AS is_done,
+        EXISTS (SELECT 1 FROM ai.chat_tasks schedule WHERE schedule.conversation_id = conversation.id AND schedule.state = 'active') AS has_active_schedule,
         latest.status AS latest_turn_status,
+        ${browserWorkPending()} AS latest_browser_pending,
         latest.error AS latest_turn_error,
         latest.completed_at AS latest_turn_completed_at
       FROM ai.conversations conversation
       LEFT JOIN LATERAL (
-        SELECT status, error, completed_at
+        SELECT status, error, completed_at, live_blocks
         FROM ai.turns
-        WHERE conversation_id = conversation.id
+        WHERE NOT COALESCE(run_config ? 'background', false) AND conversation_id = conversation.id
         ORDER BY created_at DESC, id DESC
         LIMIT 1
       ) latest ON TRUE
       WHERE conversation.created_by_user_id = ${input.ownerUserId}
         AND (${archived}::boolean = (conversation.archived_at IS NOT NULL))
+        AND (${input.done ?? null}::boolean IS NULL OR ${input.done ?? null}::boolean = ${effectiveDone()})
         AND (${input.projectId ?? null}::uuid IS NULL OR conversation.project_id = ${input.projectId ?? null}::uuid)
         AND (NOT ${Boolean(input.unassigned)}::boolean OR conversation.project_id IS NULL)
         AND (${pattern}::text IS NULL
@@ -1079,10 +1237,12 @@ export const aiConversations: AiConversationService = {
                 OR message.search_document @@ websearch_to_tsquery('simple', ${query ?? ""}))
           ))
         AND (${status}::text IS NULL
-          OR (${status} = 'running' AND latest.status IN ('queued', 'running'))
-          OR (${status} = 'needs_attention' AND latest.status = 'waiting_for_action')
+          OR (${status} = 'running' AND (latest.status IN ('queued', 'running') OR ${browserWorkPending()}))
+          OR (${status} = 'needs_attention' AND latest.status = 'waiting_for_action' AND NOT ${browserWorkPending()})
           OR (${status} = 'failed' AND latest.status = 'failed')
-          OR (${status} = 'unread' AND latest.status = 'completed' AND latest.completed_at > COALESCE(conversation.last_viewed_at, '-infinity')))
+          OR (${status} = 'unread' AND (
+            (latest.status = 'completed' AND latest.completed_at > COALESCE(conversation.last_viewed_at, '-infinity'))
+            OR conversation.background_received_at > COALESCE(conversation.last_viewed_at, '-infinity'))))
       ORDER BY ${order}
       LIMIT ${perPage}
       OFFSET ${offset}
@@ -1092,14 +1252,15 @@ export const aiConversations: AiConversationService = {
       SELECT COUNT(*) AS total
       FROM ai.conversations conversation
       LEFT JOIN LATERAL (
-        SELECT status, completed_at
+        SELECT status, completed_at, live_blocks
         FROM ai.turns
-        WHERE conversation_id = conversation.id
+        WHERE NOT COALESCE(run_config ? 'background', false) AND conversation_id = conversation.id
         ORDER BY created_at DESC, id DESC
         LIMIT 1
       ) latest ON TRUE
       WHERE conversation.created_by_user_id = ${input.ownerUserId}
         AND (${archived}::boolean = (conversation.archived_at IS NOT NULL))
+        AND (${input.done ?? null}::boolean IS NULL OR ${input.done ?? null}::boolean = ${effectiveDone()})
         AND (${input.projectId ?? null}::uuid IS NULL OR conversation.project_id = ${input.projectId ?? null}::uuid)
         AND (NOT ${Boolean(input.unassigned)}::boolean OR conversation.project_id IS NULL)
         AND (${pattern}::text IS NULL
@@ -1115,10 +1276,12 @@ export const aiConversations: AiConversationService = {
                 OR message.search_document @@ websearch_to_tsquery('simple', ${query ?? ""}))
           ))
         AND (${status}::text IS NULL
-          OR (${status} = 'running' AND latest.status IN ('queued', 'running'))
-          OR (${status} = 'needs_attention' AND latest.status = 'waiting_for_action')
+          OR (${status} = 'running' AND (latest.status IN ('queued', 'running') OR ${browserWorkPending()}))
+          OR (${status} = 'needs_attention' AND latest.status = 'waiting_for_action' AND NOT ${browserWorkPending()})
           OR (${status} = 'failed' AND latest.status = 'failed')
-          OR (${status} = 'unread' AND latest.status = 'completed' AND latest.completed_at > COALESCE(conversation.last_viewed_at, '-infinity')))
+          OR (${status} = 'unread' AND (
+            (latest.status = 'completed' AND latest.completed_at > COALESCE(conversation.last_viewed_at, '-infinity'))
+            OR conversation.background_received_at > COALESCE(conversation.last_viewed_at, '-infinity'))))
     `;
     const total = Number(countRows[0]?.total ?? 0);
     return {
@@ -1138,68 +1301,7 @@ export const aiConversations: AiConversationService = {
     return loadConversationSummary(input);
   },
 
-  saveDraft: async (input) =>
-    sql.begin(async (tx) => {
-      const [conversation] = await tx<
-        { draft_content: unknown; draft_revision: number | string; draft_updated_at: Date | string | null }[]
-      >`
-        SELECT draft_content, draft_revision, draft_updated_at
-        FROM ai.conversations
-        WHERE id = ${input.conversationId}::uuid
-          AND created_by_user_id = ${input.ownerUserId}::uuid
-          AND archived_at IS NULL
-        FOR UPDATE
-      `;
-      if (!conversation) return { ok: false as const, reason: "not_found" as const };
-      if (Number(conversation.draft_revision) !== input.expectedRevision) {
-        return { ok: false as const, reason: "conflict" as const };
-      }
-      const [sameDraft] = await tx<{ same: boolean }[]>`
-        SELECT ${JSON.stringify(input.content)}::jsonb = ${JSON.stringify(parseJsonValue(conversation.draft_content))}::jsonb AS same
-      `;
-      if (sameDraft?.same) {
-        return {
-          ok: true as const,
-          draft: {
-            content: input.content,
-            revision: Number(conversation.draft_revision),
-            updatedAt: conversation.draft_updated_at ? iso(conversation.draft_updated_at) : null,
-          },
-        };
-      }
-
-      for (const part of input.content) {
-        if (part.type !== "file") continue;
-        const [file] = await tx<{ exists: boolean }[]>`
-          SELECT EXISTS (
-            SELECT 1 FROM ai.files
-            WHERE conversation_id = ${input.conversationId}::uuid
-              AND path = ${part.path}
-              AND media_type = ${part.mediaType}
-              AND size = ${part.size}
-              AND version = ${part.version}
-          ) AS exists
-        `;
-        if (!file?.exists) throw new Error(`Conversation file changed or no longer exists: ${part.path}`);
-      }
-
-      const [saved] = await tx<{ draft_content: unknown; draft_revision: number | string; draft_updated_at: Date | string }[]>`
-        UPDATE ai.conversations
-        SET draft_content = ${JSON.stringify(input.content)}::jsonb,
-            draft_revision = draft_revision + 1,
-            draft_updated_at = now()
-        WHERE id = ${input.conversationId}::uuid
-        RETURNING draft_content, draft_revision, draft_updated_at
-      `;
-      return {
-        ok: true as const,
-        draft: {
-          content: parseJsonValue<AiConversationDraft["content"]>(saved!.draft_content),
-          revision: Number(saved!.draft_revision),
-          updatedAt: iso(saved!.draft_updated_at),
-        },
-      };
-    }),
+  saveDraft: async (input) => sql.begin((tx) => saveAiDraftInTransaction(tx, input)),
 
   getLoadedTools: async (input) => {
     const rows = await sql<{ loaded_tools: string[] | null }[]>`
@@ -1420,7 +1522,7 @@ export const aiConversations: AiConversationService = {
   },
 
   createInterChatMessage: async (input) => {
-    const existing = await sql<InterChatMessageRow[]>`${interChatMessageSelect}
+    const existing = await sql<InterChatMessageRow[]>`${interChatMessageSelect()}
       WHERE message.idempotency_key = ${input.idempotencyKey}
         AND message.source_conversation_id = ${input.sourceConversationId}::uuid
         AND message.actor_user_id = ${input.actorUserId}::uuid
@@ -1465,21 +1567,22 @@ export const aiConversations: AiConversationService = {
         RETURNING id
       `,
     );
-    const rows = await sql<InterChatMessageRow[]>`${interChatMessageSelect} WHERE message.id = ${inserted[0]!.id}::uuid LIMIT 1`;
+    const rows = await sql<InterChatMessageRow[]>`${interChatMessageSelect()} WHERE message.id = ${inserted[0]!.id}::uuid LIMIT 1`;
     return { ok: true, message: rowToInterChatMessage(rows[0]!) };
   },
 
   listPendingInterChatMessages: async (input = {}) => {
     const limit = Math.min(Math.max(Math.floor(input.limit ?? 50), 1), 100);
     const rows = await sql<InterChatMessageRow[]>`
-      ${interChatMessageSelect}
+      ${interChatMessageSelect()}
       WHERE message.status = 'pending'
         AND (${input.targetConversationId ?? null}::uuid IS NULL OR message.target_conversation_id = ${input.targetConversationId ?? null}::uuid)
         AND (${input.targetConversationId ?? null}::uuid IS NOT NULL OR NOT EXISTS (
           SELECT 1
           FROM ai.turns active_turn
           WHERE active_turn.conversation_id = message.target_conversation_id
-            AND active_turn.status IN ('queued', 'running', 'waiting_for_action')
+            AND NOT COALESCE(active_turn.run_config ? 'background', false)
+      AND active_turn.status IN ('queued', 'running', 'waiting_for_action')
         ))
         AND (${input.targetConversationId ?? null}::uuid IS NOT NULL OR message.id = (
           SELECT oldest.id
@@ -1508,7 +1611,7 @@ export const aiConversations: AiConversationService = {
   deliverInterChatMessage: async (input) => {
     const delivered = await sql.begin(async (tx) => {
       const rows = await tx<InterChatMessageRow[]>`
-        ${interChatMessageSelect}
+        ${interChatMessageSelect()}
         WHERE message.id = ${input.messageId}::uuid
         FOR UPDATE OF message
       `;
@@ -1534,6 +1637,7 @@ export const aiConversations: AiConversationService = {
       const [active] = await tx<{ id: string }[]>`
         SELECT id FROM ai.turns
         WHERE conversation_id = ${message.target_conversation_id}::uuid
+          AND NOT COALESCE(run_config ? 'background', false)
           AND status IN ('queued', 'running', 'waiting_for_action')
         LIMIT 1
       `;
@@ -1548,6 +1652,7 @@ export const aiConversations: AiConversationService = {
           RETURNING *
         `,
       );
+      await tx`UPDATE ai.conversations SET done = CASE WHEN done IS TRUE THEN NULL ELSE done END, last_used_at = now() WHERE id = ${message.target_conversation_id}::uuid`;
       const turn = rowToTurn(turnRows[0]!);
       const targetMeta: NonNullable<AiStoredMessage["meta"]> = {
         agentMessage: {
@@ -1579,7 +1684,7 @@ export const aiConversations: AiConversationService = {
         SET status = 'delivered', target_turn_id = ${turn.id}, target_message_id = ${messageRow.id}, delivered_at = now()
         WHERE id = ${message.id}::uuid
       `;
-      const updated = await tx<InterChatMessageRow[]>`${interChatMessageSelect} WHERE message.id = ${message.id}::uuid LIMIT 1`;
+      const updated = await tx<InterChatMessageRow[]>`${interChatMessageSelect()} WHERE message.id = ${message.id}::uuid LIMIT 1`;
       return { delivered: true as const, message: rowToInterChatMessage(updated[0]!), turn };
     });
     return delivered;
@@ -1624,12 +1729,16 @@ export const aiConversations: AiConversationService = {
       `;
       if (!conversations[0]) return { ok: false as const, reason: "not_found" as const };
 
+      if (input.onlyUnassigned && conversations[0].project_id) return { ok: false as const, reason: "already_assigned" as const };
+
       const [activity] = await tx<{ exists: boolean }[]>`
         SELECT EXISTS (
           SELECT 1 FROM ai.turns
           WHERE conversation_id = ${input.conversationId}::uuid
             AND status IN ('queued', 'running', 'waiting_for_action')
-        ) AS exists
+        ) OR (${Boolean(input.onlyUnassigned)}::boolean AND EXISTS (
+          SELECT 1 FROM ai.queued_messages WHERE conversation_id = ${input.conversationId}::uuid AND status IN ('pending','failed')
+        )) AS exists
       `;
       if (activity?.exists) return { ok: false as const, reason: "active_turn" as const };
 
@@ -1659,6 +1768,35 @@ export const aiConversations: AiConversationService = {
     return rows[0] ? loadConversationSummary(input) : null;
   },
 
+  setConversationDone: async (input) => {
+    const result = await sql.begin(async (tx) => {
+      // Same lock as turn submission: completion cannot race a new message.
+      const [conversation] = await tx<{ id: string }[]>`
+        SELECT id FROM ai.conversations
+        WHERE id = ${input.conversationId}::uuid AND created_by_user_id = ${input.ownerUserId}::uuid
+          AND archived_at IS NULL FOR UPDATE
+      `;
+      if (!conversation) return { ok: false as const, reason: "not_found" as const };
+      if (input.done) {
+        const [active] = await tx<{ id: string }[]>`
+          SELECT id FROM ai.turns WHERE conversation_id = ${input.conversationId}::uuid
+            AND NOT COALESCE(run_config ? 'background', false) AND status IN ('queued', 'running', 'waiting_for_action') LIMIT 1
+        `;
+        const [pending] =
+          await tx`SELECT id FROM ai.queued_messages WHERE conversation_id = ${input.conversationId}::uuid AND status IN ('pending','failed') LIMIT 1`;
+        if (active || pending) return { ok: false as const, reason: "active_turn" as const };
+      }
+      await tx`UPDATE ai.conversations
+        SET done = ${input.done}::boolean,
+            last_used_at = CASE WHEN ${input.done}::boolean IS FALSE THEN now() ELSE last_used_at END
+        WHERE id = ${input.conversationId}::uuid`;
+      return { ok: true as const };
+    });
+    if (!result.ok) return result;
+    const conversation = await loadConversationSummary(input);
+    return conversation ? { ok: true as const, conversation } : { ok: false as const, reason: "not_found" as const };
+  },
+
   archiveConversation: async (input) => {
     const rows = await sql<{ id: string }[]>`
       UPDATE ai.conversations
@@ -1672,6 +1810,7 @@ export const aiConversations: AiConversationService = {
           WHERE conversation_id = ai.conversations.id
             AND status IN ('queued', 'running', 'waiting_for_action')
         )
+        AND NOT EXISTS (SELECT 1 FROM ai.queued_messages WHERE conversation_id = ai.conversations.id AND status IN ('pending','failed'))
       RETURNING id
     `;
     return Boolean(rows[0]);
@@ -1727,7 +1866,7 @@ export const aiConversations: AiConversationService = {
         AND EXISTS (SELECT 1 FROM ai.messages m WHERE m.conversation_id = c.id)
         AND NOT EXISTS (
           SELECT 1 FROM ai.turns t
-          WHERE t.conversation_id = c.id AND t.status IN ('queued', 'running', 'waiting_for_action')
+          WHERE t.conversation_id = c.id AND NOT COALESCE(t.run_config ? 'background', false) AND t.status IN ('queued', 'running', 'waiting_for_action')
         )
       ORDER BY c.updated_at ASC
       LIMIT ${limit}
@@ -2075,7 +2214,7 @@ export const aiConversations: AiConversationService = {
   listTurnMessages: async (input) => {
     const rows = await sql<MessageRow[]>`
       SELECT *
-      FROM ai.messages
+      FROM (SELECT * FROM ai.messages UNION ALL SELECT * FROM ai.task_messages) messages
       WHERE conversation_id = ${input.conversationId}
         AND loop_id = ${input.loopId}
         AND (${input.includeCompacted ?? false} OR compacted_at IS NULL)
@@ -2139,7 +2278,8 @@ export const aiConversations: AiConversationService = {
           usage,
           stop_reason,
           loop_aggregate,
-          loop_done_reason
+          loop_done_reason,
+          meta
         )
         SELECT
           short_id,
@@ -2155,7 +2295,8 @@ export const aiConversations: AiConversationService = {
           usage,
           stop_reason,
           loop_aggregate,
-          loop_done_reason
+          loop_done_reason,
+          CASE WHEN ${todoMetaJson()} ? 'todoPlan' THEN jsonb_build_object('todoPlan', ${todoMetaJson()}->'todoPlan') ELSE NULL END
         FROM ai.messages
         WHERE conversation_id = ${input.sourceConversationId}
           AND compacted_at IS NULL
@@ -2184,13 +2325,15 @@ export const aiConversations: AiConversationService = {
 
   setLatestAssistantLoopAggregate: async (input) => {
     const loopId = input.loopId ?? null;
+    const config = loopId ? await aiConversations.getTurnRunConfig({ conversationId: input.conversationId, turnId: loopId }) : null;
+    const table = config?.kind === "chat" && config.background ? "ai.task_messages" : "ai.messages";
     await sql`
-      UPDATE ai.messages
-      SET loop_aggregate = ${JSON.stringify(input.aggregate)}::jsonb,
+      UPDATE ${sql(table)}
+      SET loop_aggregate = ${JSON.stringify(input.aggregate)}::text::jsonb,
           loop_done_reason = ${input.doneReason}
       WHERE id = (
         SELECT id
-        FROM ai.messages
+        FROM ${sql(table)}
         WHERE conversation_id = ${input.conversationId}
           AND compacted_at IS NULL
           AND kind = 'message'
@@ -2214,9 +2357,18 @@ export const aiConversations: AiConversationService = {
         WHERE conversation_id = ${input.conversationId}
           AND compacted_at IS NULL
           AND seq <= ${checkpointSeq}
+          AND ${visibleToTurn(input.turnId)}
       `;
       if ((rows[0]?.count ?? 0) === 0) return;
 
+      const plans = await tx<{ plan: unknown }[]>`
+        SELECT CASE WHEN role = 'tool_result' THEN ${todoMessageJson()}->'result' ELSE ${todoMetaJson()}->'todoPlan' END AS plan
+        FROM ai.messages WHERE conversation_id = ${input.conversationId} AND seq <= ${checkpointSeq}
+          AND ${visibleToTurn(input.turnId)}
+          AND ((role = 'tool_result' AND ${todoMessageJson()}->>'name' = 'todo_write' AND COALESCE(${todoMessageJson()}->>'isError','false') = 'false') OR ${todoMetaJson()} ? 'todoPlan')
+        ORDER BY seq DESC, id DESC LIMIT 1
+      `;
+      const todoPlan = parseAiTodoPlan(plans[0]?.plan);
       const archived = await tx<{ count: number }[]>`
         WITH archived AS (
           UPDATE ai.messages
@@ -2224,6 +2376,7 @@ export const aiConversations: AiConversationService = {
           WHERE conversation_id = ${input.conversationId}
             AND compacted_at IS NULL
             AND seq <= ${checkpointSeq}
+            AND ${visibleToTurn(input.turnId)}
           RETURNING id
         )
         SELECT COUNT(*)::int AS count FROM archived
@@ -2232,41 +2385,46 @@ export const aiConversations: AiConversationService = {
       await insertMessageLocked(
         {
           conversationId: input.conversationId,
-          message: input.summary,
+          message:
+            todoPlan && input.summary.role === "assistant"
+              ? {
+                  ...input.summary,
+                  content: [
+                    ...input.summary.content,
+                    { type: "text", text: `Working plan at this checkpoint:\n${JSON.stringify(todoPlan)}` },
+                  ],
+                }
+              : input.summary,
           kind: "summary",
           seq: checkpointSeq,
           loopId: null,
           modelProfileId: input.modelProfileId ?? null,
-          meta: { compactedCount: archived[0]?.count ?? 0 },
+          meta: { compactedCount: archived[0]?.count ?? 0, ...(todoPlan ? { todoPlan } : {}) },
         },
         tx,
       );
     });
   },
 
-  createCompactionTurn: async (input) => {
-    const rows = await withAiShortId(
-      "idx_ai_turns_conversation_short_id",
-      (shortId) => sql<TurnRow[]>`
-      INSERT INTO ai.turns (
-        short_id,
-        conversation_id,
-        model_profile_id,
-        status,
-        run_config
-      )
-      VALUES (
-        ${shortId},
-        ${input.conversationId},
-        ${input.modelProfileId},
-        'queued',
-        (${input.runConfig ? JSON.stringify(input.runConfig) : null}::text)::jsonb
-      )
+  createCompactionTurn: async (input) =>
+    sql.begin(async (tx) => {
+      const [conversation] = await tx<{ id: string }[]>`
+      SELECT id FROM ai.conversations WHERE id = ${input.conversationId}::uuid AND archived_at IS NULL FOR UPDATE
+    `;
+      if (!conversation) throw new Error("Conversation not found.");
+      const rows = await withAiShortIdForDb(
+        tx,
+        "idx_ai_turns_conversation_short_id",
+        (attempt, shortId) => attempt<TurnRow[]>`
+      INSERT INTO ai.turns (short_id, conversation_id, model_profile_id, status, run_config)
+      VALUES (${shortId}, ${input.conversationId}, ${input.modelProfileId}, 'queued',
+        (${input.runConfig ? JSON.stringify(input.runConfig) : null}::text)::jsonb)
       RETURNING *
     `,
-    );
-    return rowToTurn(rows[0]!);
-  },
+      );
+      await tx`UPDATE ai.conversations SET done = CASE WHEN done IS TRUE THEN NULL ELSE done END, last_used_at = now() WHERE id = ${input.conversationId}::uuid`;
+      return rowToTurn(rows[0]!);
+    }),
 
   submitChatTurn: async (input) => {
     return await sql.begin(async (tx) => {
@@ -2274,6 +2432,20 @@ export const aiConversations: AiConversationService = {
         SELECT draft_revision, project_id FROM ai.conversations WHERE id = ${input.conversationId} FOR UPDATE
       `;
       if (!conversation) throw new Error("Conversation not found.");
+      if (input.queuedMessageId) {
+        const [head] = await tx<
+          { id: string; status: string }[]
+        >`SELECT id, status FROM ai.queued_messages WHERE conversation_id = ${input.conversationId}::uuid AND status IN ('pending','failed') ORDER BY position LIMIT 1`;
+        const [busy] =
+          await tx`SELECT id FROM ai.turns WHERE conversation_id = ${input.conversationId}::uuid AND NOT COALESCE(run_config ? 'background', false) AND status IN ('queued','running','waiting_for_action') LIMIT 1`;
+        if (!head || head.id !== input.queuedMessageId || head.status !== "pending" || busy)
+          throw new Error("Queued message is no longer ready.");
+      }
+      if (!input.queuedMessageId) {
+        const [queued] =
+          await tx`SELECT id FROM ai.queued_messages WHERE conversation_id = ${input.conversationId}::uuid AND status IN ('pending','failed') LIMIT 1`;
+        if (queued) throw new Error("Queued messages must be sent first.");
+      }
       if (input.expectedDraftRevision !== undefined && Number(conversation.draft_revision) !== input.expectedDraftRevision) {
         throw new Error("Conversation draft changed before the turn was submitted.");
       }
@@ -2309,13 +2481,22 @@ export const aiConversations: AiConversationService = {
         RETURNING *
       `,
       );
+      // Queue acceptance already recorded the user's interaction time.
+      if (!input.queuedMessageId)
+        await tx`UPDATE ai.conversations SET done = CASE WHEN done IS TRUE THEN NULL ELSE done END, last_used_at = now() WHERE id = ${input.conversationId}::uuid`;
       const turn = rowToTurn(turnRows[0]!);
       const attachedFiles = input.runConfig.files?.attached ?? [];
       for (const file of attachedFiles) {
-        const copied = input.retrySourceTurnId
-          ? await tx<{ path: string }[]>`
-          INSERT INTO ai.turn_files (turn_id, path, bytes, media_type, size, origin, updated_at, version)
-          SELECT ${turn.id}::uuid, path, bytes, media_type, size, origin, updated_at, version
+        const copied = input.queuedMessageId
+          ? await tx<
+              { path: string }[]
+            >`INSERT INTO ai.turn_files(turn_id,path,bytes,media_type,size,origin,dictation_recorded_at,updated_at,version)
+              SELECT ${turn.id}::uuid,path,bytes,media_type,size,origin,dictation_recorded_at,updated_at,version FROM ai.queued_message_files
+              WHERE message_id = ${input.queuedMessageId}::uuid AND path = ${file.path} RETURNING path`
+          : input.retrySourceTurnId
+            ? await tx<{ path: string }[]>`
+          INSERT INTO ai.turn_files (turn_id, path, bytes, media_type, size, origin, dictation_recorded_at, updated_at, version)
+          SELECT ${turn.id}::uuid, path, bytes, media_type, size, origin, dictation_recorded_at, updated_at, version
           FROM ai.turn_files
           WHERE turn_id = ${input.retrySourceTurnId}::uuid
             AND path = ${file.path}
@@ -2324,9 +2505,9 @@ export const aiConversations: AiConversationService = {
             AND version = ${file.version ?? -1}
           RETURNING path
         `
-          : await tx<{ path: string }[]>`
-          INSERT INTO ai.turn_files (turn_id, path, bytes, media_type, size, origin, updated_at, version)
-          SELECT ${turn.id}::uuid, path, bytes, media_type, size, origin, updated_at, version
+            : await tx<{ path: string }[]>`
+          INSERT INTO ai.turn_files (turn_id, path, bytes, media_type, size, origin, dictation_recorded_at, updated_at, version)
+          SELECT ${turn.id}::uuid, path, bytes, media_type, size, origin, dictation_recorded_at, updated_at, version
           FROM ai.files
           WHERE conversation_id = ${input.conversationId}::uuid
             AND path = ${file.path}
@@ -2342,6 +2523,7 @@ export const aiConversations: AiConversationService = {
           conversationId: input.conversationId,
           message: input.userMessage,
           loopId: turn.id,
+          meta: input.expectedDraftRevision === undefined ? undefined : { submittedDraftRevision: input.expectedDraftRevision },
         },
         tx,
       );
@@ -2375,6 +2557,10 @@ export const aiConversations: AiConversationService = {
           WHERE id = ${input.conversationId}::uuid
         `;
       }
+      if (input.queuedMessageId) {
+        await tx`UPDATE ai.queued_messages SET status = 'submitted', submission = '{}'::jsonb, content = '[]'::jsonb WHERE id = ${input.queuedMessageId}::uuid`;
+        await tx`DELETE FROM ai.queued_message_files WHERE message_id = ${input.queuedMessageId}::uuid`;
+      }
       return { turn, message: rowToMessage(messageRow) };
     });
   },
@@ -2390,6 +2576,14 @@ export const aiConversations: AiConversationService = {
     return rows[0]?.run_config ? parseJsonValue<AiTurnRunConfig>(rows[0].run_config) : null;
   },
 
+  getLatestTurn: async (input) => {
+    const [row] = await sql<
+      TurnRow[]
+    >`SELECT * FROM ai.turns WHERE conversation_id = ${input.conversationId}::uuid AND NOT COALESCE(run_config ? 'background', false)
+      ORDER BY created_at DESC, id DESC LIMIT 1`;
+    return row ? rowToTurn(row) : null;
+  },
+
   getTurn: async (input) => {
     const rows = await sql<TurnRow[]>`
       SELECT *
@@ -2417,6 +2611,7 @@ export const aiConversations: AiConversationService = {
       SELECT *
       FROM ai.turns
       WHERE conversation_id = ${input.conversationId}
+        AND NOT COALESCE(run_config ? 'background', false)
         AND status IN ('queued', 'running', 'waiting_for_action')
       ORDER BY created_at DESC
       LIMIT 1
@@ -2431,7 +2626,7 @@ export const aiConversations: AiConversationService = {
 
   claimTurn: async (input) => {
     const leaseMs = boundedMs(input.leaseMs, 60_000, 5_000, 5 * 60_000);
-    const runBudgetMs = boundedMs(input.runBudgetMs, 10 * 60_000, 10_000, 60 * 60_000);
+    const runBudgetMs = Number.isFinite(input.runBudgetMs) && input.runBudgetMs >= 0 ? input.runBudgetMs : 30 * 60_000;
     const maxAttempts = Math.max(1, Math.floor(input.maxAttempts));
     const rows = await sql<TurnRow[]>`
       UPDATE ai.turns
@@ -2440,9 +2635,11 @@ export const aiConversations: AiConversationService = {
           lease_owner = ${input.leaseOwner},
           lease_expires_at = now() + (${leaseMs} * interval '1 millisecond'),
           heartbeat_at = now(),
+          run_budget_ms = COALESCE(run_budget_ms, ${runBudgetMs}),
           deadline = CASE
-            WHEN ${input.from} = 'waiting' THEN now() + (${runBudgetMs} * interval '1 millisecond')
-            ELSE COALESCE(deadline, now() + (${runBudgetMs} * interval '1 millisecond'))
+            WHEN COALESCE(run_budget_ms, ${runBudgetMs}) = 0 THEN NULL
+            WHEN ${input.from} = 'waiting' OR deadline IS NULL THEN now() + (COALESCE(run_budget_ms, ${runBudgetMs}) * interval '1 millisecond')
+            ELSE deadline
           END
       WHERE id = ${input.turnId}
         AND conversation_id = ${input.conversationId}
@@ -2686,7 +2883,7 @@ export const aiConversations: AiConversationService = {
       UPDATE ai.turns
       SET status = 'failed',
           completed_at = now(),
-          error = 'AI turn exceeded its execution budget.',
+          error = 'Run time limit reached. You can continue the task in a new message.',
           lease_owner = NULL,
           lease_expires_at = NULL,
           live_blocks = NULL
@@ -2853,14 +3050,14 @@ export const aiConversations: AiConversationService = {
         ${input.callId},
         ${input.kind},
         ${input.name},
-        ${JSON.stringify(input.args ?? null)}::jsonb,
+        ${JSON.stringify(input.args ?? null)}::text::jsonb,
         ${input.message ?? null},
-        ${input.review ? JSON.stringify(input.review) : null}::jsonb,
+        ${input.review ? JSON.stringify(input.review) : null}::text::jsonb,
         ${input.approvalScope},
         ${input.allowAlways},
         ${input.frontendMode ?? null},
         ${input.resolvedEvent ? "resolved" : "pending"},
-        ${input.resolvedEvent ? JSON.stringify(input.resolvedEvent) : null}::jsonb,
+        ${input.resolvedEvent ? JSON.stringify(input.resolvedEvent) : null}::text::jsonb,
         CASE WHEN ${Boolean(input.resolvedEvent)} THEN now() ELSE NULL END
       )
       ON CONFLICT (turn_id, call_id)
@@ -2928,7 +3125,7 @@ export const aiConversations: AiConversationService = {
     const rows = await sql<PendingActionRow[]>`
       UPDATE ai.pending_actions
       SET status = 'resolved',
-          resolved_event = ${JSON.stringify(input.event)}::jsonb,
+          resolved_event = ${JSON.stringify(input.event)}::text::jsonb,
           resolved_at = now()
       WHERE conversation_id = ${input.conversationId}
         AND turn_id = ${input.turnId}
@@ -3054,7 +3251,23 @@ export const aiConversations: AiConversationService = {
   createSessionStore: (input): SessionStore => ({
     load: async (): Promise<StoreEntry[]> => {
       // The loop must only ever see the active model context, never archived history.
-      const rows = await aiConversations.listContextMessages({ conversationId: input.conversationId });
+      if (input.background && input.turnId) {
+        const own = await aiConversations.listTurnMessages({ conversationId: input.conversationId, loopId: input.turnId });
+        const context = input.background.context;
+        return [...context, ...own.map((row) => ({ seq: context.length + row.seq, kind: row.kind, message: row.message }))];
+      }
+      // Results delivered after this turn started belong to the next turn's context.
+      // Compare durable message sequences rather than wall-clock timestamps.
+      const rows = input.turnId
+        ? (
+            await sql<MessageRow[]>`
+            SELECT * FROM ai.messages
+            WHERE conversation_id = ${input.conversationId}::uuid AND compacted_at IS NULL
+              AND ${visibleToTurn(input.turnId)}
+            ORDER BY seq ASC
+          `
+          ).map(rowToMessage)
+        : await aiConversations.listContextMessages({ conversationId: input.conversationId });
       return rows.map((row) => ({
         seq: row.seq,
         kind: row.kind,
@@ -3077,19 +3290,21 @@ export const aiConversations: AiConversationService = {
 
       if (input.turnId && input.leaseOwner) {
         const appended = await appendTurnOwnedMessage({
+          background: Boolean(input.background),
           conversationId: input.conversationId,
           turnId: input.turnId,
           leaseOwner: input.leaseOwner,
           message,
           kind: opts?.kind,
           seq: opts?.seq,
-          loopId: opts?.kind === "summary" ? null : input.turnId,
+          loopId: opts?.kind === "summary" && !input.background ? null : input.turnId,
           modelProfileId: input.modelProfileId,
           meta,
         });
         if (!appended) {
           throw new Error("AI turn lost its lease while writing a message.");
         }
+        await input.onMessage?.(appended);
         return;
       }