@k2b/cloud 0.7.0 → 0.9.0

package/src/ai/settings.ts

@@ -1,6 +1,6 @@
-import { AiModelPricingSchema } from "../shared/ai-costs";
 import { z } from "zod";
 import { coreSettings } from "../services";
+import { AiModelPricingSchema } from "../shared/ai-costs";
 import { getAiCredential, listAiCredentialProfileIds } from "./credentials";
 import { AI_FIRECRAWL_API_KEY_SETTING_KEY } from "./firecrawl-tools";
 import { createAiProvider } from "./provider";

package/src/ai/short-id.ts

@@ -14,13 +14,12 @@ export const withAiShortId = async <T>(
     try {
       return await insert(allocate());
     } catch (error) {
-      const uniqueViolation = typeof error === "object" && error !== null && (("code" in error && error.code === "23505") || ("errno" in error && error.errno === "23505"));
-      const collision =
+      const uniqueViolation =
         typeof error === "object" &&
         error !== null &&
-        uniqueViolation &&
-        "constraint" in error &&
-        error.constraint === constraint;
+        (("code" in error && error.code === "23505") || ("errno" in error && error.errno === "23505"));
+      const collision =
+        typeof error === "object" && error !== null && uniqueViolation && "constraint" in error && error.constraint === constraint;
       if (!collision) throw error;
     }
   }

package/src/ai/skill-search.ts

@@ -11,14 +11,15 @@ export async function withAiSkillSearch<T>(query: string, run: (bm25: boolean) =
     SELECT EXISTS (SELECT 1 FROM pg_extension WHERE extname = 'pg_textsearch')
       AND EXISTS (SELECT 1 FROM pg_class c JOIN pg_am am ON am.oid = c.relam
         WHERE c.oid = to_regclass(${BM25_INDEX}) AND am.amname = 'bm25') AS available
-  `.then(rows => rows[0]?.available ?? false);
+  `.then((rows) => rows[0]?.available ?? false);
   const bm25 = await bm25Available;
   try {
     return await run(bm25);
   } catch (error) {
-    const capabilityLost = typeof error === "object" && error !== null &&
-      ["code", "errno"].some(key => key in error &&
-        ["0A000", "42704", "42883", "55000"].includes(String(Reflect.get(error, key))));
+    const capabilityLost =
+      typeof error === "object" &&
+      error !== null &&
+      ["code", "errno"].some((key) => key in error && ["0A000", "42704", "42883", "55000"].includes(String(Reflect.get(error, key))));
     if (!bm25 || !capabilityLost) throw error;
     bm25Available = Promise.resolve(false);
     return run(false);
@@ -29,19 +30,29 @@ export function aiSkillSearchSql(query: string, bm25: boolean) {
   const terms = [...new Set(query.toLowerCase().match(/[\p{L}\p{N}]+/gu) ?? [])];
   // Match every term in either field. Short prefixes stay exact; longer terms
   // tolerate typos without matching unrelated short words throughout the catalog.
-  const matches = !query ? sql`TRUE` : !terms.length ? sql`FALSE` : sql`
+  const matches = !query
+    ? sql`TRUE`
+    : !terms.length
+      ? sql`FALSE`
+      : sql`
     NOT EXISTS (SELECT 1 FROM unnest(${toPgTextArray(terms)}::text[]) AS term
       WHERE strpos(lower(skill.name), term) = 0 AND strpos(lower(skill.description), term) = 0
         AND (length(term) < 4 OR greatest(word_similarity(term, skill.name),
           word_similarity(term, skill.description)) < 0.35))
   `;
-  const rank = !query ? sql`0::real` : sql`
+  // Rank typos against whole words: a partial-word extent such as "invi…" in a
+  // description must not outscore the typo'd name "invoices" it was meant for.
+  const rank = !query
+    ? sql`0::real`
+    : sql`
     CASE WHEN lower(skill.name) = ${query.toLowerCase()} THEN 100 ELSE 0 END
     + CASE WHEN strpos(lower(skill.name), ${query.toLowerCase()}) > 0 THEN 10 ELSE 0 END
-    + 2 * word_similarity(${query}, skill.name) + word_similarity(${query}, skill.description)
+    + 2 * strict_word_similarity(${query}, skill.name) + strict_word_similarity(${query}, skill.description)
   `;
-  const textRank = !query ? sql`0::real` : bm25
-    ? sql`-(skill.search_text <@> to_bm25query(${query}, ${BM25_INDEX}))`
-    : sql`ts_rank_cd(to_tsvector('simple', skill.search_text), plainto_tsquery('simple', ${query}))`;
+  const textRank = !query
+    ? sql`0::real`
+    : bm25
+      ? sql`-(skill.search_text <@> to_bm25query(${query}, ${BM25_INDEX}))`
+      : sql`ts_rank_cd(to_tsvector('simple', skill.search_text), plainto_tsquery('simple', ${query}))`;
   return { matches, rank, textRank };
 }

package/src/ai/skill-seeds.ts

@@ -1,5 +1,5 @@
-import { ASSISTANT_DATA_ANALYSIS_SKILL } from "./data-analysis-skill";
 import { ASSISTANT_CODE_MODE_SKILL } from "./code-mode-skill";
+import { ASSISTANT_DATA_ANALYSIS_SKILL } from "./data-analysis-skill";
 import { CLOUD_GRIDS_INSTRUCTIONS, CLOUD_GRIDS_QUERY_REFERENCE } from "./grids-skill";
 import type { AiSkillTemplate } from "./skills";
 
@@ -296,9 +296,17 @@ refer to an existing schedule, list tasks before creating a duplicate.
    notebook constraint exists on an action that accepts only a note ID.
 4. Explain the scope through the normal create/update review. Grants authorize
    this task's capability use, not new access to resources. Always-approval
-   capabilities cannot be granted. Interactive browser and Code Mode are not
-   available in background runs; explain an unsupported requirement rather than
-   promising it will work unattended.
+   capabilities cannot be granted. Code Mode can run unattended on the server:
+   load its Skill for calculations, chat-file processing, AI tasks and exports.
+   Code capability calls inherit this task's grants, including fixed inputs.
+   HTTP and RSQL use the same grants list: kind http with fixedInput fields
+   origin, url and/or method; kind database with resourceId, operation and/or
+   table. Empty fixedInput grants all supported targets/operations within current
+   access. Prefer a resourceId-only database grant when a task needs connect and
+   multiple operations; a fixed operation also requires a separate connect grant.
+   HTTP secrets must already be configured in the chat or app. Interactive dialogs,
+   secret entry and capability binary streams are unavailable in scheduled code.
+   Explain those requirements instead of promising unattended interaction.
 5. Create the task. Confirm its actual saved timing, timezone and destination only
    after success. Queued or manually started does not mean completed.
 
@@ -430,7 +438,7 @@ const BUILTIN_CLOUD_AI_SKILLS: AiSkillTemplate[] = [
   ASSISTANT_CODE_MODE_SKILL,
   ASSISTANT_DATA_ANALYSIS_SKILL,
   {
-    version: 4,
+    version: 5,
     key: "grids:cloud-grids",
     name: "cloud-grids",
     description:
@@ -447,10 +455,11 @@ const BUILTIN_CLOUD_AI_SKILLS: AiSkillTemplate[] = [
     instructions: CLOUD_ASSISTANT_INSTRUCTIONS,
   },
   {
-    version: 1,
+    version: 2,
     key: "assistant:scheduled-tasks",
     name: "scheduled-tasks",
-    description: "Create and manage one-time reminders, delayed jobs and recurring scheduled background tasks in Cloud Assistant. Use for requests such as remind me tomorrow, check in an hour, every morning, or changing, pausing, resuming and repairing a scheduled task, including missing permissions or failed runs.",
+    description:
+      "Create and manage one-time reminders, delayed jobs and recurring scheduled background tasks in Cloud Assistant. Use for requests such as remind me tomorrow, check in an hour, every morning, or changing, pausing, resuming and repairing a scheduled task, including missing permissions or failed runs.",
     instructions: SCHEDULED_TASKS_INSTRUCTIONS,
   },
   {

package/src/ai/skill-tool.ts

@@ -13,7 +13,12 @@ export async function loadSelectedAiSkills(ids: readonly string[], turnId: strin
     if (!subject || !allowed) throw new Error("The selected Skill requires a model and tool scope that allow Skills.");
     const skill = await aiSkills.loadForTurn(turnId, { id }, subject);
     if (!skill) throw new Error(`Selected Skill ${id} is unavailable or access was revoked.`);
-    loaded.push({ name: skill.name, revision: skill.revision, instructions: skill.instructions, files: skill.files.map(file => file.path) });
+    loaded.push({
+      name: skill.name,
+      revision: skill.revision,
+      instructions: skill.instructions,
+      files: skill.files.map((file) => file.path),
+    });
   }
   return loaded;
 }

package/src/ai/skills-routes.ts

@@ -1,8 +1,8 @@
-import { aiProjects } from "./projects";
 import { Hono, type MiddlewareHandler } from "hono";
 import { z } from "zod";
 import { AuthenticatedPrincipalSchema } from "../contracts/shared";
 import { type AuthContext, auth, err, fail, ok, rateLimit, respond, v } from "../server";
+import { aiProjects } from "./projects";
 import {
   AI_SKILL_DESCRIPTION_MAX_CHARS,
   AI_SKILL_EXTRA_FRONTMATTER_MAX_CHARS,
@@ -64,27 +64,44 @@ const buildAiSkillsRoutes = (dependencies: AiSkillsRouteDependencies = {}) =>
       const skills = q === undefined ? await aiSkills.list(subject) : (await aiSkills.search(subject, q)).skills;
       return respond(c, ok({ skills: skills.map(publicSummary) }));
     })
-    .get("/project-links/:projectId", v("query", z.object({ q: z.string().max(200).default(""), page: z.coerce.number().int().min(1).max(100000).default(1), available: z.enum(["true","false"]).default("false") })), async c => {
-      const subject = c.get("accessSubject") ?? null, query = c.req.valid("query");
-      const project = await aiProjects.getByShortId(c.req.param("projectId")!, subject, query.available === "true" ? "admin" : "read");
-      const result = project ? await aiSkills.projectSkills(project.id, subject, { query:query.q, page:query.page, available:query.available === "true" }) : null;
-      return result ? respond(c, ok({ ...result, items:result.items.map(publicSummary) })) : respond(c, fail(err.notFound("Project")));
-    })
-    .get("/:skillId/projects", async c => {
+    .get(
+      "/project-links/:projectId",
+      v(
+        "query",
+        z.object({
+          q: z.string().max(200).default(""),
+          page: z.coerce.number().int().min(1).max(100000).default(1),
+          available: z.enum(["true", "false"]).default("false"),
+        }),
+      ),
+      async (c) => {
+        const subject = c.get("accessSubject") ?? null,
+          query = c.req.valid("query");
+        const project = await aiProjects.getByShortId(c.req.param("projectId")!, subject, query.available === "true" ? "admin" : "read");
+        const result = project
+          ? await aiSkills.projectSkills(project.id, subject, { query: query.q, page: query.page, available: query.available === "true" })
+          : null;
+        return result ? respond(c, ok({ ...result, items: result.items.map(publicSummary) })) : respond(c, fail(err.notFound("Project")));
+      },
+    )
+    .get("/:skillId/projects", async (c) => {
       const subject = c.get("accessSubject") ?? null;
       const skill = await aiSkills.getByShortId(c.req.param("skillId")!, subject, "admin");
       const projects = skill ? await aiSkills.linkedProjects(skill.id, subject) : null;
-      return projects ? respond(c, ok({ projects:projects.map(project => ({ id:project.shortId, name:project.name })) })) : respond(c, fail(err.notFound("Skill")));
+      return projects
+        ? respond(c, ok({ projects: projects.map((project) => ({ id: project.shortId, name: project.name })) }))
+        : respond(c, fail(err.notFound("Skill")));
     })
-    .put("/:skillId/projects/:projectId", v("json", z.object({ linked:z.boolean() }).strict()), async c => {
+    .put("/:skillId/projects/:projectId", v("json", z.object({ linked: z.boolean() }).strict()), async (c) => {
       const subject = c.get("accessSubject") ?? null;
-      const [skill,project] = await Promise.all([
-        aiSkills.getByShortId(c.req.param("skillId")!,subject,"admin"),
-        aiProjects.getByShortId(c.req.param("projectId")!,subject,"admin"),
+      const [skill, project] = await Promise.all([
+        aiSkills.getByShortId(c.req.param("skillId")!, subject, "admin"),
+        aiProjects.getByShortId(c.req.param("projectId")!, subject, "admin"),
       ]);
       const linked = c.req.valid("json").linked;
-      return skill && project && await aiSkills.linkProject(skill.id,project.id,linked,subject)
-        ? respond(c,ok({linked})) : respond(c,fail(err.notFound("Skill or Project")));
+      return skill && project && (await aiSkills.linkProject(skill.id, project.id, linked, subject))
+        ? respond(c, ok({ linked }))
+        : respond(c, fail(err.notFound("Skill or Project")));
     })
     .get("/templates/:name", dependencies.authenticate ?? auth.requireRole("authenticated"), (c) => {
       if (!c.get("accessSubject")) return respond(c, fail(err.forbidden("Skill templates require an authenticated access subject.")));

package/src/ai/skills.ts

@@ -1,8 +1,6 @@
-import { aiProjects } from "./projects";
-import { AuthenticatedPrincipalSchema } from "../contracts/shared";
 import { createHash } from "node:crypto";
-import { accessRevision } from "../server/services/access-revision";
 import { type SQL, type SQLQuery, sql } from "bun";
+import { AuthenticatedPrincipalSchema } from "../contracts/shared";
 import type { AccessSubject } from "../server";
 import {
   buildAccessPrincipalCondition,
@@ -12,9 +10,10 @@ import {
   type PermissionLevel,
   type Principal,
 } from "../server/services/access";
+import { accessRevision } from "../server/services/access-revision";
 import { toPgUuidArray } from "../services/postgres";
-import { aiSkillSearchSql, withAiSkillSearch } from "./skill-search";
 import { mountAiSkillFilePath } from "./file-mount";
+import { aiProjects } from "./projects";
 import { AI_SHORT_ID_PATTERN, withAiShortIdForDb } from "./short-id";
 import {
   type AiSkillExtraFrontmatter,
@@ -26,6 +25,7 @@ import {
   validateAiSkillName,
   validateAiSkillReferences,
 } from "./skill-format";
+import { aiSkillSearchSql, withAiSkillSearch } from "./skill-search";
 import { getBuiltinAiSkillTemplates } from "./skill-seeds";
 import type { AiSkillFileToolContent, AiSkillFileToolStat } from "./types";
 
@@ -187,15 +187,17 @@ const principalForSubject = (subject: AccessSubject): Principal =>
     : { type: "service_account", serviceAccountId: subject.serviceAccountId };
 
 const accessMatch = (subject: AccessSubject | null): SQLQuery =>
-  subject === null ? sql`FALSE` : buildAccessPrincipalCondition({
-    subject,
-    columns: {
-      userId: sql`access.user_id`,
-      groupId: sql`access.group_id`,
-      serviceAccountId: sql`access.service_account_id`,
-      authenticatedOnly: sql`access.authenticated_only`,
-    },
-  });
+  subject === null
+    ? sql`FALSE`
+    : buildAccessPrincipalCondition({
+        subject,
+        columns: {
+          userId: sql`access.user_id`,
+          groupId: sql`access.group_id`,
+          serviceAccountId: sql`access.service_account_id`,
+          authenticatedOnly: sql`access.authenticated_only`,
+        },
+      });
 
 const getRow = async (skillId: string, db: SQL = sql): Promise<SkillRow | null> =>
   (await db<SkillRow[]>`SELECT * FROM ai.skills WHERE id = ${skillId}::uuid`)[0] ?? null;
@@ -220,7 +222,9 @@ const effectivePermission = (skillId: SQLQuery, subject: AccessSubject | null) =
 `;
 
 const permissionFor = async (skillId: string, subject: AccessSubject | null, db: SQL = sql): Promise<AiSkillPermission | "none"> => {
-  const [row] = await db<{ permission: AiSkillPermission | null }[]>`SELECT (${effectivePermission(sql`${skillId}::uuid`, subject)}) AS permission`;
+  const [row] = await db<
+    { permission: AiSkillPermission | null }[]
+  >`SELECT (${effectivePermission(sql`${skillId}::uuid`, subject)}) AS permission`;
   return row?.permission ?? "none";
 };
 
@@ -332,8 +336,7 @@ const createSkillAccess = async (
 };
 
 const checkAccessRevision = async (skillId: string, expected: string | undefined, db: SQL) => {
-  if (expected !== undefined && accessRevision(await listSkillAccess(skillId, db)) !== expected)
-    throw new AiSkillRevisionConflictError();
+  if (expected !== undefined && accessRevision(await listSkillAccess(skillId, db)) !== expected) throw new AiSkillRevisionConflictError();
 };
 
 const updateSkillAccess = async (skillId: string, accessId: string, permission: AiSkillPermission, db: SQL): Promise<boolean> => {
@@ -493,9 +496,14 @@ const skillSnapshotFiles = (skill: AiSkill): { path: string; content: string }[]
 ];
 
 type SkillListOptions = { query?: string; enabledOnly?: boolean; limit?: number };
-async function listSkillSummaries(subject: AccessSubject | null, options: SkillListOptions & {
-  project?: { id: string; linked: boolean }; manageOnly?: boolean; offset?: number;
-} = {}): Promise<AiSkillSummary[]> {
+async function listSkillSummaries(
+  subject: AccessSubject | null,
+  options: SkillListOptions & {
+    project?: { id: string; linked: boolean };
+    manageOnly?: boolean;
+    offset?: number;
+  } = {},
+): Promise<AiSkillSummary[]> {
   const userId = subject?.type === "user" ? subject.userId : null;
   const query = (options.query ?? "").trim().slice(0, 200);
   const limit = Math.max(1, Math.min(201, options.limit ?? 200));
@@ -535,7 +543,9 @@ async function listSkillSummaries(subject: AccessSubject | null, options: SkillL
 }
 
 async function linkedSkillProjects(skillId: string, subject: AccessSubject | null) {
-  const links = await sql<{projectId:string}[]>`SELECT project_id AS "projectId" FROM ai.project_skills WHERE skill_id=${skillId}::uuid ORDER BY project_id`;
+  const links = await sql<
+    { projectId: string }[]
+  >`SELECT project_id AS "projectId" FROM ai.project_skills WHERE skill_id=${skillId}::uuid ORDER BY project_id`;
   const result: Array<{ projectId: string; shortId: string | null; name: string | null }> = [];
   for (const link of links) {
     const project = await aiProjects.get(link.projectId, subject);
@@ -630,20 +640,30 @@ export const aiSkills = {
     return listSkillSummaries(subject, options);
   },
 
-  async projectSkills(projectId: string, subject: AccessSubject | null, options: { query?: string; page?: number; available?: boolean } = {}) {
+  async projectSkills(
+    projectId: string,
+    subject: AccessSubject | null,
+    options: { query?: string; page?: number; available?: boolean } = {},
+  ) {
     if (!(await aiProjects.get(projectId, subject, options.available ? "admin" : "read"))) return null;
     const page = Math.max(1, Math.min(100000, Math.trunc(options.page ?? 1)));
-    const skills = await listSkillSummaries(subject, { query: options.query, limit: 31, offset: (page-1)*30,
-      project: { id: projectId, linked: !options.available }, manageOnly: options.available });
-    return { items: skills.slice(0,30), hasNext: skills.length>30, page };
+    const skills = await listSkillSummaries(subject, {
+      query: options.query,
+      limit: 31,
+      offset: (page - 1) * 30,
+      project: { id: projectId, linked: !options.available },
+      manageOnly: options.available,
+    });
+    return { items: skills.slice(0, 30), hasNext: skills.length > 30, page };
   },
 
   async linkProject(skillId: string, projectId: string, linked: boolean, subject: AccessSubject | null): Promise<boolean> {
     if (!(await aiProjects.get(projectId, subject, "admin"))) return false;
-    return sql.begin(async tx => {
+    return sql.begin(async (tx) => {
       const [row] = await tx`SELECT id FROM ai.skills WHERE id=${skillId}::uuid FOR UPDATE`;
       if (!row || !hasPermission(await permissionFor(skillId, subject, tx), "admin")) return false;
-      if (linked) await tx`INSERT INTO ai.project_skills(project_id,skill_id) VALUES(${projectId}::uuid,${skillId}::uuid) ON CONFLICT DO NOTHING`;
+      if (linked)
+        await tx`INSERT INTO ai.project_skills(project_id,skill_id) VALUES(${projectId}::uuid,${skillId}::uuid) ON CONFLICT DO NOTHING`;
       else await tx`DELETE FROM ai.project_skills WHERE project_id=${projectId}::uuid AND skill_id=${skillId}::uuid`;
       return true;
     });
@@ -722,7 +742,7 @@ export const aiSkills = {
   },
 
   async listAccess(skillId: string, subject: AccessSubject | null): Promise<AiSkillAccess[] | null> {
-    return sql.begin(async tx => {
+    return sql.begin(async (tx) => {
       const [row] = await tx<SkillRow[]>`SELECT * FROM ai.skills WHERE id=${skillId}::uuid FOR UPDATE`;
       if (!row || !hasPermission(await permissionFor(row.id, subject, tx), "admin")) return null;
       return listSkillAccess(skillId, tx);
@@ -743,7 +763,13 @@ export const aiSkills = {
     });
   },
 
-  async updateAccess(skillId: string, accessId: string, subject: AccessSubject | null, permission: AiSkillPermission, expectedAccessRevision?: string): Promise<boolean> {
+  async updateAccess(
+    skillId: string,
+    accessId: string,
+    subject: AccessSubject | null,
+    permission: AiSkillPermission,
+    expectedAccessRevision?: string,
+  ): Promise<boolean> {
     return sql.begin(async (tx) => {
       const [row] = await tx<SkillRow[]>`SELECT * FROM ai.skills WHERE id = ${skillId}::uuid FOR UPDATE`;
       if (!row || !hasPermission(await permissionFor(row.id, subject, tx), "admin")) return false;

package/src/ai/store.ts

@@ -1,12 +1,12 @@
-import { parseAiTodoPlan } from "./todo-contracts";
 import type { DoneReason, InboundEvent, LoopAggregate, Message, SessionStore, StoreEntry } from "@k2b/nessi";
 import type { Usage } from "@k2b/nessi/ai";
-import { sql, type 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,
@@ -527,7 +527,7 @@ const visibleToTurn = (turnId?: string) => sql`(
 )`;
 
 const rowToConversation = (row: ConversationRow): AiConversation => ({
-  ...(row.activity ? {activity:row.activity} : {}),
+  ...(row.activity ? { activity: row.activity } : {}),
   id: row.id,
   hasActiveSchedule: Boolean(row.has_active_schedule),
   shortId: row.short_id,
@@ -539,19 +539,24 @@ const rowToConversation = (row: ConversationRow): AiConversation => ({
   pinnedAt: row.pinned_at ? iso(row.pinned_at) : null,
   archivedAt: row.archived_at ? iso(row.archived_at) : null,
   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 ?? "")
-  ),
+  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:
-    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()),
+    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 ?? []),
@@ -859,12 +864,13 @@ const appendTurnOwnedMessage = async (input: {
   modelProfileId?: string | null;
   meta?: AiStoredMessage["meta"];
 }): 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[]>`
+  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,
@@ -883,7 +889,7 @@ const appendTurnOwnedMessage = async (input: {
       ${shortId},
       ${input.conversationId},
       CASE
-        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
+        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"},
@@ -905,12 +911,12 @@ const appendTurnOwnedMessage = async (input: {
     )
     RETURNING *
   `,
-  );
-  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;
+    );
+    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;
   });
 };
 
@@ -1776,7 +1782,8 @@ export const aiConversations: AiConversationService = {
           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`;
+        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
@@ -2378,7 +2385,16 @@ export const aiConversations: AiConversationService = {
       await insertMessageLocked(
         {
           conversationId: input.conversationId,
-          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,
+          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,
@@ -2390,20 +2406,25 @@ export const aiConversations: AiConversationService = {
     });
   },
 
-  createCompactionTurn: async (input) => sql.begin(async (tx) => {
-    const [conversation] = await tx<{ id: string }[]>`
+  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[]>`
+      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 *
-    `);
-    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]!);
-  }),
+    `,
+      );
+      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) => {
@@ -2412,12 +2433,17 @@ export const aiConversations: AiConversationService = {
       `;
       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.");
+        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`;
+        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) {
@@ -2456,16 +2482,19 @@ export const aiConversations: AiConversationService = {
       `,
       );
       // 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`;
+      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.queuedMessageId
-          ? await tx<{path:string}[]>`INSERT INTO ai.turn_files(turn_id,path,bytes,media_type,size,origin,dictation_recorded_at,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.queued_message_files
               WHERE message_id = ${input.queuedMessageId}::uuid AND path = ${file.path} RETURNING path`
           : input.retrySourceTurnId
-          ? await tx<{ path: string }[]>`
+            ? 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
@@ -2476,7 +2505,7 @@ export const aiConversations: AiConversationService = {
             AND version = ${file.version ?? -1}
           RETURNING path
         `
-          : await tx<{ path: string }[]>`
+            : 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
@@ -2548,7 +2577,9 @@ export const aiConversations: AiConversationService = {
   },
 
   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)
+    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;
   },
@@ -3223,17 +3254,19 @@ export const aiConversations: AiConversationService = {
       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 }))];
+        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[]>`
+        ? (
+            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)
+          `
+          ).map(rowToMessage)
         : await aiConversations.listContextMessages({ conversationId: input.conversationId });
       return rows.map((row) => ({
         seq: row.seq,