@k2b/cloud 0.40.0 → 0.42.0

package/src/ai/open-questions.ts

@@ -0,0 +1,168 @@
+import { sql } from "bun";
+import { z } from "zod";
+import { APPROVALS_PAGE_SIZE } from "../contracts/approvals";
+import { CapabilityActionReviewPresentationSchema, CapabilitySemanticLinkSchema } from "../contracts/capabilities";
+import { openRequests } from "../services/approvals/content";
+import { logger } from "../services/logging";
+import { reviewShortText, toolActionCard, toolBlockReview } from "./chat/action-card";
+import { aiToolIcon } from "./chat/message-utils";
+import { legacyOutcomeWords } from "./chat/tool-action-words";
+import { type AiTurnBlock, toolBlockId } from "./protocol";
+
+export type AiOpenQuestion = {
+  /** The approval request id (approvals.requests.id). */
+  id: string;
+  /** Short id of the chat the question waits in. */
+  conversationId: string;
+  /** The chat's current title, at most 200 code points; chat content, never Cloud's words. */
+  conversationTitle: string | null;
+  /** The question's data-chat-anchor: the id of the tool block the chat renders it in. */
+  anchor: string;
+  /** The question's short form, plain text, at most 160 code points. */
+  short: string;
+  /** The app the question is about, as the card shows it. */
+  app: { name: string; icon: string; accent?: string };
+  createdAt: string;
+};
+
+export type AiOpenQuestions = {
+  items: AiOpenQuestion[];
+  /** All open questions of the person, across pages. */
+  count: number;
+};
+
+type QuestionRow = {
+  id: string;
+  conversationId: string;
+  conversationTitle: string | null;
+  displayCallId: string;
+  appId: string;
+  sentence: string;
+  toolName: string;
+  createdAt: Date;
+  block: Extract<AiTurnBlock, { kind: "tool" }> | null;
+};
+
+const log = logger("ai:open-questions");
+const legacyReviewSchema = z.object({
+  question: z.string().min(1),
+  rows: z.array(z.object({ label: z.string(), value: z.string(), format: z.enum(["date", "date-time"]).optional() })),
+  markdown: z.string().optional(),
+  summary: z.string().optional(),
+  links: z.array(CapabilitySemanticLinkSchema).optional(),
+});
+
+const ownedRequests = (ownerUserId: string) => sql`
+  SELECT r.* FROM (${openRequests(ownerUserId)}) r
+  WHERE EXISTS (
+    SELECT 1 FROM ai.pending_actions p JOIN ai.conversations c ON c.id=p.conversation_id
+    WHERE p.approval_id=r.id AND p.status='pending' AND p.kind IN ('approval','custom_approval')
+      AND c.created_by_user_id=${ownerUserId}::uuid
+  )`;
+
+/** One bounded, owner-scoped snapshot, using exactly the chat's stored question card. */
+export const listAiOpenQuestions = async (input: { ownerUserId: string; locale: string; timeZone: string }): Promise<AiOpenQuestions> => {
+  const [counts] = await sql<{ count: number }[]>`
+    SELECT count(*)::int AS count FROM (${ownedRequests(input.ownerUserId)}) r`;
+  const rows = await sql<QuestionRow[]>`
+    WITH page AS (
+      SELECT * FROM (${ownedRequests(input.ownerUserId)}) r
+      ORDER BY r.created_at DESC, r.id DESC LIMIT ${APPROVALS_PAGE_SIZE}
+    )
+    SELECT r.id, r.app_id AS "appId", r.sentence, r.created_at AS "createdAt",
+      question.short_id AS "conversationId", question.title AS "conversationTitle",
+      question.display_call_id AS "displayCallId", question.tool_name AS "toolName", question.block
+    FROM page r JOIN LATERAL (
+      SELECT c.short_id, c.title, p.tool_name,
+        CASE WHEN p.kind='custom_approval'
+          THEN COALESCE(substring(p.call_id FROM '^(.*)-approval-[0-9]+$'), p.call_id)
+          ELSE p.call_id END AS display_call_id,
+        (SELECT block FROM jsonb_array_elements(
+          CASE WHEN jsonb_typeof(t.live_blocks)='array' THEN t.live_blocks ELSE '[]'::jsonb END
+        ) AS blocks(block)
+          WHERE block->>'kind'='tool' AND block->>'callId'=p.call_id LIMIT 1) AS block
+      FROM ai.pending_actions p JOIN ai.conversations c ON c.id=p.conversation_id
+        JOIN ai.turns t ON t.id=p.turn_id
+      WHERE p.approval_id=r.id AND p.status='pending' AND p.kind IN ('approval','custom_approval')
+        AND c.created_by_user_id=${input.ownerUserId}::uuid
+      ORDER BY p.created_at DESC, p.id DESC LIMIT 1
+    ) question ON true
+    ORDER BY r.created_at DESC, r.id DESC`;
+
+  return {
+    count: counts?.count ?? 0,
+    items: rows.map((row) => openQuestionFromRow(row, input)),
+  };
+};
+
+/** Stop at the payload bound without splitting a Unicode code point or copying the rest of a legacy message. */
+const boundedText = (text: string, max: number): string => {
+  const points: string[] = [];
+  for (const point of text) {
+    if (points.length === max) return `${points.slice(0, max - 1).join("")}…`;
+    points.push(point);
+  }
+  return text;
+};
+
+/** Present one stored question without database access. */
+export const openQuestionFromRow = (row: QuestionRow, input: { locale: string; timeZone: string }): AiOpenQuestion => {
+  const block = row.block;
+  const presentation = block?.presentation;
+  const question: AiOpenQuestion = {
+    id: row.id,
+    conversationId: row.conversationId,
+    conversationTitle: row.conversationTitle === null ? null : boundedText(row.conversationTitle, 200),
+    // The id the chat renders the card under: a custom approval's card carries its parent call, also when a stored
+    // block still has the approval's own id (see normalizeCustomApprovalBlocks in client/projection.ts).
+    anchor: toolBlockId(row.displayCallId),
+    short: boundedText(row.sentence.split(/\r?\n/, 1)[0] ?? "", 160),
+    app: {
+      name: typeof presentation?.appName === "string" ? presentation.appName : block ? "Cloud" : row.appId,
+      icon: aiToolIcon(
+        typeof block?.name === "string" ? block.name : row.toolName,
+        typeof presentation?.appIcon === "string" ? presentation.appIcon : undefined,
+      ),
+      ...(typeof presentation?.appAccent === "string" ? { accent: presentation.appAccent } : {}),
+    },
+    createdAt: row.createdAt.toISOString(),
+  };
+  if (!block) return question;
+  try {
+    if (
+      typeof block.id !== "string" ||
+      !block.id ||
+      typeof block.name !== "string" ||
+      !block.name ||
+      typeof block.callId !== "string" ||
+      !["running", "awaiting_approval", "awaiting_client", "completed", "failed", "rejected"].includes(block.status)
+    )
+      throw new Error("Malformed tool block");
+    if (block.review == null && block.approval?.review != null) CapabilityActionReviewPresentationSchema.parse(block.approval.review);
+    const review = toolBlockReview(block);
+    if (review !== null) {
+      if ("legacy" in review) legacyReviewSchema.parse(review.legacy);
+      else CapabilityActionReviewPresentationSchema.parse(review);
+    }
+    const card = toolActionCard(block, {
+      locale: input.locale,
+      timeZone: input.timeZone,
+      outcome: legacyOutcomeWords(block, input.locale, input.timeZone),
+    });
+    const short =
+      review && !("legacy" in review)
+        ? reviewShortText(review, { locale: input.locale, timeZone: input.timeZone, app: card.app })
+        : card.questionText;
+    if (
+      typeof short !== "string" ||
+      typeof card.app.name !== "string" ||
+      typeof card.app.icon !== "string" ||
+      (card.app.accent !== undefined && typeof card.app.accent !== "string")
+    )
+      throw new Error("Malformed question card");
+    return { ...question, short: boundedText(short, 160), app: card.app };
+  } catch {
+    log.warn("Failed to present open question", { approvalId: row.id, conversationId: row.conversationId });
+    return question;
+  }
+};

package/src/ai/projects.ts

@@ -295,8 +295,7 @@ const listProjectAccess = async (projectId: string, db: SQL = sql): Promise<AiPr
   const rows = await db<ProjectAccessRow[]>`
     SELECT project_access.short_id, access.user_id, access.group_id, access.service_account_id, access.authenticated_only,
            access.permission, access.created_at,
-           COALESCE(NULLIF(users.display_name, ''), users.uid, groups.name, service_accounts.name,
-             CASE WHEN access.authenticated_only THEN 'All authenticated users' ELSE 'Public' END) AS display_name,
+           COALESCE(NULLIF(users.display_name, ''), users.uid, groups.name, service_accounts.name) AS display_name,
            users.avatar_hash, service_accounts.kind AS service_account_kind
     FROM ai.project_access project_access
     JOIN auth.access access ON access.id = project_access.access_id

package/src/ai/protocol.ts

@@ -1,5 +1,5 @@
 import type { CompactResult, InboundEvent, Message } from "@k2b/nessi";
-import type { CapabilityActionReviewData } from "../contracts/capabilities";
+import type { CapabilityActionReviewPresentation } from "../contracts/capabilities";
 import type { AiActionCheck, AiStoredActionReview } from "./action-review";
 import type { AiConversation, AiFrontendToolMode, AiStoredMessage, AiToolPresentation, AiTurnStatus } from "./types";
 
@@ -49,7 +49,7 @@ export type AiTurnBlock =
       /** Present while status is awaiting_approval. */
       approval?: {
         message?: string;
-        review?: CapabilityActionReviewData;
+        review?: CapabilityActionReviewPresentation;
         allowAlways: boolean;
         /** Whether the approval can be remembered for this chat. */
         allowChat?: boolean;

package/src/ai/question-text.ts

@@ -0,0 +1,8 @@
+/**
+ * The plain-text form of an Assistant question, the same one the chat card shows: for `cld`, notifications, and Cloud
+ * Login. Pure and browser-safe, in its own entry so neither the CLI bundle nor browser bundles that use
+ * `@k2b/cloud/ai/browser` pull it in by accident.
+ */
+export { type ApprovalCardInput, approvalCard } from "../approvals/approval-card";
+export type { ActionCard } from "./chat/action-card";
+export { type ActionQuestionText, type ActionTextRow, actionCardText, actionQuestionLines } from "./chat/action-text";

package/src/ai/recent-resources.ts

@@ -1,7 +1,8 @@
 import { z } from "zod";
 import { resolveCapabilityManifestPresentation } from "../_internal/capabilities";
-import { listCapabilities } from "../_internal/registry";
-import { type CapabilityDispatchParams, dispatchCapability, QUERY_TIMEOUT_MS } from "../api/capabilities";
+import { CAPABILITY_DISCOVERY_TIMEOUT_MS } from "../_internal/capability-timeout";
+import { type listApps, listCapabilities } from "../_internal/registry";
+import { type CapabilityDispatchParams, dispatchCapability } from "../api/capabilities";
 import {
   CloudResourceRefSchema,
   capabilityResultSchema,
@@ -11,6 +12,7 @@ import {
 } from "../contracts/capabilities";
 import type { CapabilityRegistryEntry } from "../contracts/registry";
 import type { RequestAuthority } from "../server";
+import { discoverableAppEntries } from "../services/app-discovery";
 import { resolveAppIdentityPresentation } from "../shared/app-presentation";
 import { LOCALE_HEADER } from "../shared/locale";
 import { CODE_SOURCE_TOOLS } from "./code-source-contracts";
@@ -65,6 +67,7 @@ const studioReader = async (input: {
 export type AiRecentResourceDependencies = {
   store?: Pick<AiConversationService, "listRecentSentResourceRefs">;
   listRegistry?: () => Promise<CapabilityRegistryEntry[]>;
+  listApps?: typeof listApps;
   dispatch?: (params: CapabilityDispatchParams) => Promise<Response>;
   skills?: Pick<typeof aiSkills, "list">;
   studioReader?: typeof studioReader;
@@ -108,7 +111,7 @@ export const listAiRecentResources = async (input: {
   dependencies?: AiRecentResourceDependencies;
 }): Promise<AiRecentResource[]> => {
   const deps = input.dependencies ?? {};
-  const signal = AbortSignal.any([input.signal, AbortSignal.timeout(deps.timeoutMs ?? QUERY_TIMEOUT_MS)]);
+  const signal = AbortSignal.any([input.signal, AbortSignal.timeout(deps.timeoutMs ?? CAPABILITY_DISCOVERY_TIMEOUT_MS)]);
   // Unreadable history is no answer, not an empty one: the request fails, so the browser asks again at its next opening.
   const sent = await withinBudget(signal, () =>
     (deps.store ?? aiConversations).listRecentSentResourceRefs({ ownerUserId: input.ownerUserId }),
@@ -118,10 +121,14 @@ export const listAiRecentResources = async (input: {
   const skillIds = candidates.flatMap(({ ref }) => (ref.type === "core.ai.skill" ? [ref.id] : []));
   // Exactly the sent Skills, so a large Skill catalog never pushes one out; failing, they are left out like a reader.
   const skills = skillIds.length
-    ? withinBudget(signal, () => (deps.skills ?? aiSkills).list(input.authority.accessSubject, { shortIds: skillIds })).catch(() => [])
+    ? withinBudget(signal, () =>
+        (deps.skills ?? aiSkills).list(input.authority.accessSubject, { shortIds: skillIds, authority: input.authority }),
+      ).catch(() => [])
     : Promise.resolve([]);
   const registry = candidates.some(({ ref }) => ref.type !== "core.ai.skill" && ref.type !== "assistant.artifact")
-    ? withinBudget(signal, deps.listRegistry ?? listCapabilities).catch(() => [])
+    ? withinBudget(signal, async () =>
+        discoverableAppEntries(input.authority, await (deps.listRegistry ?? listCapabilities)(), deps.listApps),
+      ).catch(() => [])
     : Promise.resolve([]);
   const resources = await Promise.all(
     candidates.map(async (candidate): Promise<AiRecentResource | null> => {

package/src/ai/review-content.ts

@@ -0,0 +1,77 @@
+import { type SQL, sql } from "bun";
+import { capabilityRequestHash } from "../capabilities/claims";
+import { parseStoredReviewContent } from "../capabilities/review-storage";
+import { CAPABILITY_MAX_REVIEW_CONTENT_BYTES, type CapabilityActionReviewPresentation } from "../contracts/capabilities";
+import type { AiStoredActionReview } from "./action-review";
+
+export type ReviewContentLocation = { conversationId: string; turnId: string; callId: string };
+
+export const reviewContentHref = ({ conversationId, turnId, callId }: ReviewContentLocation): string =>
+  `/api/approvals/conversations/${encodeURIComponent(conversationId)}/turns/${encodeURIComponent(turnId)}/reviews/${encodeURIComponent(callId)}`;
+
+export const compactCapabilityReview = (
+  review: CapabilityActionReviewPresentation,
+  location: ReviewContentLocation,
+): CapabilityActionReviewPresentation => {
+  if (!("sentence" in review)) return review;
+  const { content, ...compact } = review;
+  const digest = content ? capabilityRequestHash(content) : compact.contentRef?.digest;
+  return digest ? { ...compact, contentRef: { href: reviewContentHref(location), digest } } : compact;
+};
+
+/** The existing message snapshot owns both the content and its integrity reference. */
+export const storedReviewWithContent = (review: AiStoredActionReview, location: ReviewContentLocation): AiStoredActionReview =>
+  "content" in review && review.content
+    ? { ...review, contentRef: { href: reviewContentHref(location), digest: capabilityRequestHash(review.content) } }
+    : review;
+
+/** Rebind the locator on a fork; never make the new conversation depend on access to its source. */
+export const compactStoredReview = (review: AiStoredActionReview, location?: ReviewContentLocation): AiStoredActionReview => {
+  if ("legacy" in review) return review;
+  const { content: _content, ...compact } = review;
+  return compact.contentRef && location
+    ? { ...compact, contentRef: { ...compact.contentRef, href: reviewContentHref(location) } }
+    : compact;
+};
+
+/** Project before transferring JSONB out of Postgres, not after loading every full review into Core. */
+export const compactReviewMapSql = (reviews: SQL.Query<unknown>) => sql`(
+  SELECT COALESCE(jsonb_object_agg(entry.key, entry.value - 'content'), '{}'::jsonb)
+  FROM jsonb_each(CASE WHEN jsonb_typeof(${reviews}) = 'object' THEN ${reviews} ELSE '{}'::jsonb END) entry
+)`;
+
+export const compactReviewMetaSql = (meta: SQL.Query<unknown>) => sql`CASE
+  WHEN ${meta} ? 'toolReviews' THEN jsonb_set(${meta}, '{toolReviews}', ${compactReviewMapSql(sql`${meta}->'toolReviews'`)})
+  ELSE ${meta} END`;
+
+/** Caller has already authorized this conversation. Read one exact persisted call from either existing message store. */
+export const readReviewContent = async (location: ReviewContentLocation, digest: string, ownerUserId: string, signal?: AbortSignal) => {
+  signal?.throwIfAborted();
+  const query = sql<{ content: unknown }[]>`
+    SELECT meta->'toolReviews'->${location.callId}->'content' AS content
+    FROM (
+      SELECT meta, conversation_id, loop_id, role, seq FROM ai.messages
+      UNION ALL
+      SELECT meta, conversation_id, loop_id, role, seq FROM ai.task_messages
+    ) messages
+    WHERE conversation_id=${location.conversationId}::uuid AND loop_id=${location.turnId} AND role='assistant'
+      AND EXISTS (SELECT 1 FROM ai.conversations c WHERE c.id=messages.conversation_id
+        AND c.created_by_user_id=${ownerUserId}::uuid AND c.archived_at IS NULL)
+      AND meta->'toolReviews'->${location.callId}->'contentRef'->>'digest'=${digest}
+      AND octet_length((meta->'toolReviews'->${location.callId}->'content')::text) <= ${2 * CAPABILITY_MAX_REVIEW_CONTENT_BYTES + 2}
+    ORDER BY seq DESC LIMIT 1`;
+  // JSONB adds spaces after punctuation; at most twice the compact JSON budget. The exact limit is checked below.
+  const abort = () => query.cancel();
+  signal?.addEventListener("abort", abort, { once: true });
+  if (signal?.aborted) abort();
+  let rows: { content: unknown }[];
+  try {
+    rows = await query;
+  } finally {
+    signal?.removeEventListener("abort", abort);
+  }
+  signal?.throwIfAborted();
+  const row = rows[0];
+  const parsed = parseStoredReviewContent(row?.content);
+  return parsed.success && capabilityRequestHash(parsed.data) === digest ? parsed.data : null;
+};

package/src/ai/routes.ts

@@ -2,10 +2,11 @@ import { type Context, Hono } from "hono";
 import { bodyLimit } from "hono/body-limit";
 import { describeRoute } from "hono-openapi";
 import { z } from "zod";
-import { listCapabilities } from "../_internal/registry";
-import { QUERY_TIMEOUT_MS } from "../api/capabilities";
+import { CAPABILITY_DISCOVERY_TIMEOUT_MS, capabilityTimeoutMs } from "../_internal/capability-timeout";
+import { getApp, listCapabilities } from "../_internal/registry";
 import { ErrorResponseSchema } from "../contracts";
 import { APPROVAL_CLIENT_HEADER } from "../contracts/approvals";
+import { capabilityActionPolicy } from "../contracts/capabilities";
 import {
   type AccessSubject,
   type AuthContext,
@@ -26,12 +27,16 @@ import { isAppSessionActor } from "../server/actor";
 import { isRequestCredentialCurrent } from "../server/middleware/auth";
 import { noTransform } from "../server/middleware/no-transform";
 import { REQUEST_IDLE_TIMEOUT_SECONDS, setRequestTimeout } from "../server/request-timeout";
-import { approvalDecisionChannel } from "../services/approvals";
+import { appAccessAuthority } from "../services/app-access";
+import { discoverableAppEntries } from "../services/app-discovery";
+import { approvalDecisionChannel, approvals } from "../services/approvals";
+import { pendingApprovalReview } from "../services/approvals/question";
 import { ImageMetadataError } from "../services/image-metadata";
 import { logger } from "../services/logging";
 import { coreSettings } from "../services/settings/api";
+import { resolveAppIdentityPresentation } from "../shared/app-presentation";
 import { readThemeFromCookieHeader } from "../shared/theme";
-import { isUnknownActionOutcome } from "./action-review";
+import { type AiStoredActionReview, isLegacyActionReview, isUnknownActionOutcome, storedActionReview } from "./action-review";
 import { assistantAiSettingsState, listAssistantAiModels, resolveAssistantAudioModel, selectAssistantAiModelId } from "./assistant-models";
 import { AI_AUDIO_MAX_BYTES } from "./audio-format";
 import { buildAiCapabilityCatalog } from "./capabilities";
@@ -96,7 +101,14 @@ import { AI_SHORT_ID_PATTERN } from "./short-id";
 import { selectAiSkillCatalog } from "./skill-catalog";
 import { createCloudAiLoadSkillTool, createCloudAiSearchSkillsTool } from "./skill-tool";
 import { aiSkills } from "./skills";
-import { AI_TOOL_CHECK_STALE_MS, aiConversations, claimAiToolCheck, readAiToolCheck, settleAiToolCheck } from "./store";
+import {
+  AI_TOOL_CHECK_STALE_MS,
+  AiConversationCreationError,
+  aiConversations,
+  claimAiToolCheck,
+  readAiToolCheck,
+  settleAiToolCheck,
+} from "./store";
 import { createAiConversationStreamResponse, loadAiStreamState } from "./stream";
 import { composeAiSystemPrompt } from "./system-prompt";
 import { aiToolAudit } from "./tool-audit";
@@ -283,13 +295,17 @@ const prepareConversationForMessageRetry = async (conversationId: string): Promi
   return (await aiConversations.getActiveTurn({ conversationId })) ? "busy" : "ready";
 };
 
-const prepareLaunchDraft = async (body: z.infer<typeof AiCreateConversationInputSchema>, subject: AccessSubject | null) => {
+const prepareLaunchDraft = async (
+  body: z.infer<typeof AiCreateConversationInputSchema>,
+  subject: AccessSubject | null,
+  authority: import("../server").RequestAuthority | null = null,
+) => {
   const content = [...(body.draft?.content ?? [])];
   if (body.skills?.length && body.allowedTools && !body.allowedTools.includes("load_skill")) {
     return fail(err.badInput("Linked Skills require load_skill in allowedTools."));
   }
   for (const name of new Set(body.skills ?? [])) {
-    const skill = await aiSkills.getByName(name, subject);
+    const skill = await aiSkills.getByName(name, subject, "read", authority);
     if (!skill?.enabled) return fail(err.badInput(`Skill is unavailable: ${name}`));
     if (!content.some((part) => part.type === "resource" && part.ref.type === "core.ai.skill" && part.ref.id === skill.shortId)) {
       content.push({ type: "resource", ref: { type: "core.ai.skill", id: skill.shortId }, title: skill.name, icon: "ti ti-sparkles" });
@@ -430,7 +446,9 @@ export const aiRoutes = (() => {
           if (preferredId) previewProfile = selectAiModelProfile(state, ctx.modelPolicy, preferredId);
         }
         const toolsSupported = Boolean(previewProfile?.capabilities.includes("tools"));
-        const availableSkills = toolsSupported ? (await aiSkills.list(c.get("accessSubject"))).filter((skill) => skill.enabled) : [];
+        const availableSkills = toolsSupported
+          ? (await aiSkills.list(c.get("accessSubject"), { authority: appAccessAuthority(c) })).filter((skill) => skill.enabled)
+          : [];
         const skillCatalog = selectAiSkillCatalog(
           availableSkills.filter((skill) => !skill.manualOnly).map(({ name, description }) => ({ name, description })),
           previewProfile?.contextWindow ?? 0,
@@ -444,8 +462,8 @@ export const aiRoutes = (() => {
               })),
               ...(client?.localTools === "ask" ? [createCloudAiLocalBashTool(), ...createCloudAiLocalTools()] : []),
               ...(memoryEnabled ? [createCloudAiMemoryTool()] : []),
-              ...(availableSkills.length ? [createCloudAiLoadSkillTool(c.get("accessSubject"))] : []),
-              ...(skillCatalog.omitted > 0 ? [createCloudAiSearchSkillsTool(c.get("accessSubject"))] : []),
+              ...(availableSkills.length ? [createCloudAiLoadSkillTool(c.get("accessSubject"), appAccessAuthority(c))] : []),
+              ...(skillCatalog.omitted > 0 ? [createCloudAiSearchSkillsTool(c.get("accessSubject"), [], appAccessAuthority(c))] : []),
             ]
           : [];
         const memoryToolEnabled = tools.some((tool) => tool.def.name === "memory");
@@ -494,7 +512,7 @@ export const aiRoutes = (() => {
           c.header("Cache-Control", "no-store");
           const ctx = await resolveContext(c);
           if (ctx instanceof Response) return ctx;
-          setRequestTimeout(c, Math.ceil(QUERY_TIMEOUT_MS / 1000) + REQUEST_IDLE_TIMEOUT_SECONDS);
+          setRequestTimeout(c, Math.ceil(CAPABILITY_DISCOVERY_TIMEOUT_MS / 1000) + REQUEST_IDLE_TIMEOUT_SECONDS);
           try {
             const resources = await listAiRecentResources({
               ownerUserId: ctx.ownerUserId,
@@ -574,7 +592,7 @@ export const aiRoutes = (() => {
         const body = c.req.valid("json");
         const project = body.projectId ? await aiProjects.getByShortId(body.projectId, c.get("accessSubject"), "read") : null;
         if (body.projectId && !project) return respond(c, fail(err.notFound("Project")));
-        const draft = await prepareLaunchDraft(body, c.get("accessSubject"));
+        const draft = await prepareLaunchDraft(body, c.get("accessSubject"), appAccessAuthority(c));
         if (!draft.ok) return respond(c, draft);
         const requestedCapabilityTools = (body.preloadTools ?? []).filter(
           (requested): requested is { appId: string; kind: "query" | "action"; id: string } => "appId" in requested,
@@ -582,7 +600,7 @@ export const aiRoutes = (() => {
         let catalog: ReturnType<typeof buildAiCapabilityCatalog> = [];
         if (requestedCapabilityTools.length) {
           try {
-            catalog = buildAiCapabilityCatalog(await listCapabilities());
+            catalog = buildAiCapabilityCatalog(await discoverableAppEntries(appAccessAuthority(c), await listCapabilities()));
           } catch {
             return respond(c, fail(err.internal("The live capability catalog is unavailable.")));
           }
@@ -613,24 +631,29 @@ export const aiRoutes = (() => {
         if (body.allowedTools && preloadTools.some((name) => !body.allowedTools!.includes(name!))) {
           return respond(c, fail(err.badInput("Preloaded tools must be included in allowedTools.")));
         }
-        return respond(
-          c,
-          ok(
-            publicConversation(
-              await aiConversations.createConversation({
-                ownerUserId: ctx.ownerUserId,
-                title: body.title,
-                projectId: project?.id,
-                draft: draft.data.content,
-                preloadTools: preloadTools.map((name) => name!),
-                allowedTools: body.allowedTools,
-                launchedByAppId: body.launchedByAppId,
-              }),
-              project?.shortId ?? null,
-            ),
-          ),
-          201,
-        );
+        try {
+          const conversation = await aiConversations.createConversation({
+            requestId: body.requestId,
+            ownerUserId: ctx.ownerUserId,
+            title: body.title,
+            projectId: project?.id,
+            draft: draft.data.content,
+            preloadTools: preloadTools.map((name) => name!),
+            allowedTools: body.allowedTools,
+            launchedByAppId: body.launchedByAppId,
+          });
+          // A replay may return a conversation assigned to a Project since creation.
+          const currentProject = conversation.projectId
+            ? await aiProjects.get(conversation.projectId, c.get("accessSubject"), "read")
+            : null;
+          if (conversation.projectId && !currentProject) return respond(c, fail(err.notFound("Project")));
+          return respond(c, ok(publicConversation(conversation, currentProject?.shortId ?? null)), 201);
+        } catch (error) {
+          if (error instanceof AiConversationCreationError) {
+            return respond(c, fail(error.reason === "conflict" ? err.conflict(error.message) : err.notFound("Conversation")));
+          }
+          throw error;
+        }
       })
       .get("/conversations/:conversationId", async (c) => {
         const ctx = await resolveContext(c);
@@ -639,6 +662,24 @@ export const aiRoutes = (() => {
         if (!conversation) return notFound(c);
         return respond(c, ok(await conversationDetail(conversation, c.get("accessSubject"))));
       })
+      .get(
+        "/conversations/:conversationId/submission/:draftRevision",
+        v("param", z.object({ conversationId: z.string().regex(AI_SHORT_ID_PATTERN), draftRevision: z.coerce.number().int().min(0) })),
+        async (c) => {
+          const ctx = await resolveContext(c);
+          if (ctx instanceof Response) return ctx;
+          const conversation = await loadConversation(c, ctx);
+          if (!conversation) return notFound(c);
+          if (conversation.projectId && !(await aiProjects.get(conversation.projectId, c.get("accessSubject"), "read"))) return notFound(c);
+          const submission = await aiConversations.getDraftSubmission({
+            conversationId: conversation.id,
+            ownerUserId: ctx.ownerUserId,
+            revision: c.req.valid("param").draftRevision,
+          });
+          // Null is deliberately not a claim that the request was rejected.
+          return respond(c, ok({ submission }));
+        },
+      )
       .get("/conversations/:conversationId/messages", v("query", MessagesPageQuerySchema), async (c) => {
         const ctx = await resolveContext(c);
         if (ctx instanceof Response) return ctx;
@@ -1220,7 +1261,7 @@ export const aiRoutes = (() => {
         if (!turn || !callId) return notFound(c);
         const target = { conversationId: conversation.id, turnId: turn.id, callId };
         // The app's Query may take its whole budget; the request must outlast it.
-        setRequestTimeout(c, Math.ceil(QUERY_TIMEOUT_MS / 1000) + REQUEST_IDLE_TIMEOUT_SECONDS);
+        setRequestTimeout(c, Math.ceil(capabilityTimeoutMs("query") / 1000) + REQUEST_IDLE_TIMEOUT_SECONDS);
         try {
           const messages = await aiConversations.listTurnMessages({
             conversationId: conversation.id,
@@ -1253,7 +1294,7 @@ export const aiRoutes = (() => {
             message.message.role === "assistant"
               ? message.message.content.find((block) => block.type === "tool_call" && block.id === callId)
               : undefined;
-          const catalog = buildAiCapabilityCatalog(await listCapabilities());
+          const catalog = buildAiCapabilityCatalog(await discoverableAppEntries(appAccessAuthority(c), await listCapabilities()));
           const presentation = message.meta?.toolPresentations?.[callId];
           const entry = catalog.find(
             (entry) =>
@@ -1352,8 +1393,51 @@ export const aiRoutes = (() => {
         if (!conversation) return notFound(c);
         const turn = await loadTurn(conversation, c.req.param("turnId"));
         if (!turn) return notFound(c);
-        const actions = await listPendingAiTurnActions({ conversationId: conversation.id, turnId: turn.id });
-        return respond(c, ok(actions.map((action) => publicPendingAction(action, conversation.shortId, turn.shortId))));
+        const scope = { conversationId: conversation.id, turnId: turn.id };
+        const actions = await listPendingAiTurnActions(scope);
+        if (!actions.some((action) => action.type === "approval_request"))
+          return respond(c, ok(actions.map((action) => publicPendingAction(action, conversation.shortId, turn.shortId))));
+        const [records, reviews, config] = await Promise.all([
+          aiConversations.listPendingActionRecords(scope),
+          aiConversations.listTurnToolReviews(scope),
+          aiConversations.getTurnRunConfig(scope),
+        ]);
+        const locale = config?.kind !== "compact" ? (config?.locale ?? getLocale(c)) : getLocale(c);
+        let capabilities: Promise<Awaited<ReturnType<typeof listCapabilities>> | null> | undefined;
+        const presented = await Promise.all(
+          actions.map(async (action) => {
+            const result = publicPendingAction(action, conversation.shortId, turn.shortId);
+            if (action.type !== "approval_request") return result;
+            const record = records.find((record) => record.callId === action.callId);
+            const request = record?.approvalId ? await approvals.get(record.approvalId, undefined, true) : null;
+            const reviewCallId = record?.kind === "custom_approval" ? action.callId.replace(/-approval-[0-9]+$/, "") : action.callId;
+            const stored = reviews.get(reviewCallId);
+            let review: AiStoredActionReview | null = stored && !isLegacyActionReview(stored) ? stored : null;
+            if (!review && request) {
+              review = pendingApprovalReview({ storedReview: null, details: request.details });
+              if (review && !isLegacyActionReview(review) && !review.ask) {
+                // As the approvals page: the declared reason when the review names none, read once per listing.
+                capabilities ??= listCapabilities().catch(() => null);
+                const manifest = (await capabilities)?.find((entry) => entry.appId === request.appId)?.manifest;
+                review = storedActionReview(review, manifest ? capabilityActionPolicy(manifest, request.action) : undefined);
+              }
+            }
+            const appId = request?.appId;
+            // The name is presentation: a registry that cannot answer leaves the app ID, never the waiting approvals unread.
+            const app = appId && appId !== "assistant" ? await getApp(appId).catch(() => null) : null;
+            return {
+              ...result,
+              ...(review && !isLegacyActionReview(review) ? { review } : {}),
+              app: {
+                id: appId ?? "assistant",
+                name: app ? resolveAppIdentityPresentation(app, locale).name : appId && appId !== "assistant" ? appId : "Cloud",
+              },
+              chatTitle: conversation.title,
+              ...(request ? { expiresAt: request.expiresAt.toISOString() } : {}),
+            };
+          }),
+        );
+        return respond(c, ok(presented));
       })
       .get("/conversations/:conversationId/stream", async (c) => {
         const ctx = await resolveContext(c);

package/src/ai/runtime.ts

@@ -55,6 +55,7 @@ const log = logger("ai:runtime");
 
 const AI_WORKER_ID = `worker-${crypto.randomUUID()}`;
 const AI_TURN_HEARTBEAT_MS = 3_000;
+// Local turn orchestration (tools and approval waits included), not a model-provider quota.
 const AI_TURN_WORKER_CONCURRENCY = 8;
 const AI_TURN_MAX_ATTEMPTS = 5;