@k2b/cloud 0.6.0 → 0.8.0

package/src/ai/http.ts

@@ -4,7 +4,9 @@ import { z } from "zod";
 import { CapabilityAppIdSchema } from "../contracts/capabilities";
 import { type AuthContext, err, fail, respond } from "../server";
 import { aiAttachmentMarker } from "./attachments";
+import { CODE_RUNTIME_TOOL_NAMES } from "./browser-code-contracts";
 import { AI_TURN_ATTACHMENT_MAX_ITEMS } from "./limits";
+import { AiQuotaError } from "./quotas";
 import { AiResourceMarkerSchema } from "./resource-markers";
 import { AI_SHORT_ID_PATTERN } from "./short-id";
 import { AI_SKILL_NAME_MAX_CHARS, AI_SKILL_NAME_PATTERN } from "./skill-format";
@@ -19,21 +21,25 @@ import { isAiSettingsError } from "./validate";
 
 export const AiDraftContentPartSchema = z.discriminatedUnion("type", [
   z.object({ type: z.literal("text"), text: z.string().max(20_000) }),
-  AiResourceMarkerSchema.extend({ type: z.literal("resource") }),
+  AiResourceMarkerSchema.extend({ type: z.literal("resource"), inline: z.boolean().optional() }),
   z.object({
     type: z.literal("file"),
     path: z.string().trim().min(1).max(500),
     mediaType: z.string().trim().min(1).max(120),
     size: z.number().int().min(0),
     version: z.number().int().min(1),
+    inline: z.boolean().optional(),
   }),
+  z.object({ type: z.literal("project-file"), path: z.string().min(1).max(500).startsWith("/project/"), inline: z.boolean().optional() }),
 ]);
 
 export const AiConversationDraftInputSchema = z
   .object({
-    content: z.array(AiDraftContentPartSchema).max(20),
+    content: z.array(AiDraftContentPartSchema).max(AI_TURN_ATTACHMENT_MAX_ITEMS * 2 + 1),
   })
   .superRefine((value, context) => {
+    if (value.content.reduce((length, part) => length + (part.type === "text" ? part.text.length : 0), 0) > 20_000)
+      context.addIssue({ code: "custom", path: ["content"], message: "Draft text exceeds 20000 characters" });
     if (value.content.filter((part) => part.type !== "text").length > AI_TURN_ATTACHMENT_MAX_ITEMS) {
       context.addIssue({ code: "custom", path: ["content"], message: `A draft can attach at most ${AI_TURN_ATTACHMENT_MAX_ITEMS} items` });
     }
@@ -41,7 +47,9 @@ export const AiConversationDraftInputSchema = z
 
 export const AiInitialConversationDraftInputSchema = z
   .object({
-    content: z.array(z.union([AiDraftContentPartSchema.options[0], AiDraftContentPartSchema.options[1]])).max(20),
+    content: z
+      .array(z.union([AiDraftContentPartSchema.options[0], AiDraftContentPartSchema.options[1]]))
+      .max(AI_TURN_ATTACHMENT_MAX_ITEMS * 2 + 1),
   })
   .superRefine((value, context) => {
     if (value.content.filter((part) => part.type === "resource").length > AI_TURN_ATTACHMENT_MAX_ITEMS) {
@@ -112,7 +120,7 @@ export const AiUserContentPartSchema = z.union([
 
 export type AiTurnContentPart = z.infer<typeof AiUserContentPartSchema>;
 
-export const AiClientToolIdSchema = z.enum(["local_bash"] satisfies [AiClientToolId]);
+export const AiClientToolIdSchema = z.enum(["local_bash", ...CODE_RUNTIME_TOOL_NAMES] satisfies [AiClientToolId, ...AiClientToolId[]]);
 
 export const AiTurnInputSchema = z
   .object({
@@ -120,10 +128,14 @@ export const AiTurnInputSchema = z
     content: z
       .array(AiUserContentPartSchema)
       .min(1)
-      .max(AI_TURN_ATTACHMENT_MAX_ITEMS + 1)
+      .max(AI_TURN_ATTACHMENT_MAX_ITEMS * 2 + 1)
       .optional(),
     modelProfileId: z.string().trim().min(1).optional(),
-    clientToolIds: z.array(AiClientToolIdSchema).max(1).optional(),
+    clientToolIds: z
+      .array(AiClientToolIdSchema)
+      .max(1 + CODE_RUNTIME_TOOL_NAMES.length)
+      .refine((ids) => new Set(ids).size === ids.length, "Client tool IDs must be unique")
+      .optional(),
   })
   .refine((input) => Boolean(input.message?.trim() || input.content?.length), {
     message: "Message or content is required.",
@@ -141,9 +153,14 @@ export const AiTurnInputSchema = z
 export type AiTurnInput = z.infer<typeof AiTurnInputSchema>;
 
 export const AiSubmitConversationDraftInputSchema = z.object({
+  queueId: z.uuid().optional(),
   draftRevision: z.number().int().min(1),
   modelProfileId: z.string().trim().min(1).optional(),
-  clientToolIds: z.array(AiClientToolIdSchema).max(1).optional(),
+  clientToolIds: z
+    .array(AiClientToolIdSchema)
+    .max(1 + CODE_RUNTIME_TOOL_NAMES.length)
+    .refine((ids) => new Set(ids).size === ids.length, "Client tool IDs must be unique")
+    .optional(),
 });
 
 export const AiSteerInputSchema = z.object({
@@ -166,7 +183,7 @@ export const AiMessageRetryInputSchema = z
     content: z
       .array(AiUserContentPartSchema)
       .min(1)
-      .max(AI_TURN_ATTACHMENT_MAX_ITEMS + 1)
+      .max(AI_TURN_ATTACHMENT_MAX_ITEMS * 2 + 1)
       .optional(),
     modelProfileId: z.string().trim().min(1).optional(),
   })
@@ -245,6 +262,7 @@ const aiSettingsServiceError = (error: AiSettingsError) => {
 };
 
 export const toAiErrorResponse = (c: Context<AuthContext>, error: unknown) => {
+  if (error instanceof AiQuotaError) return c.json({ ok: false, error: error.message, message: error.message, code: error.code }, 429);
   if (isAiSettingsError(error)) {
     return respond(c, fail(aiSettingsServiceError(error.aiError)));
   }

package/src/ai/index.ts

@@ -1,4 +1,3 @@
-export { assistantAiSettingsState, listAssistantAiModels } from "./assistant-models";
 export { type AiApprovalPreferenceRoutes, type AiApprovalPreferenceView, createAiApprovalPreferenceRoutes } from "./approval-routes";
 export {
   type AiToolApprovalContext,
@@ -12,12 +11,17 @@ export {
   rememberAiToolApproval,
   revokeAiToolApprovalPreference,
 } from "./approvals";
+export { assistantAiSettingsState, listAssistantAiModels, selectAssistantAiModelId } from "./assistant-models";
 export { type AiAttachmentRef, aiAttachmentMarker, formatAiFileSize, parseAiAttachmentMarkers } from "./attachments";
+export { CloudAiTranscribeAudioInputSchema, CloudAiTranscribeAudioOutputSchema, createCloudAiTranscribeAudioTool } from "./audio-tool";
+export { CODE_RUNTIME_TOOL_NAMES, CodeResourceId, CodeRuntimeInput, parseCodeToolInput } from "./browser-code-contracts";
 export { aiCapabilityId, aiCapabilityToolName } from "./capabilities";
+export { getAiChatQuotas } from "./chat-quotas";
 export {
   type AiChatTaskOccurrenceView,
   type AiChatTaskView,
   AiConversationIdSchema,
+  ChatTaskGrantsSchema,
   ChatTaskIdSchema,
   ChatTaskOccurrenceIdSchema,
   ChatTaskScheduleInputSchema,
@@ -37,6 +41,10 @@ export {
   aiChatTasks,
 } from "./chat-tasks";
 export { parseAiSse } from "./client/transport";
+// Framework-owned managed execution host transport.
+export { CODE_CAPABILITY_TOKEN_HEADER, createCodeCapabilityTransport } from "./code-capability-transport";
+export { authorizeCodeExecution } from "./code-execution";
+export { CODE_SOURCE_TOOLS, type CodeSourceToolName } from "./code-source-contracts";
 export { listAiCredentialProfileIds } from "./credentials";
 export {
   CLOUD_AI_TEXT_EDITOR_MAX_CHARS,
@@ -66,13 +74,18 @@ export {
   shouldApplyEnrichedDescription,
   shouldApplyEnrichedTitle,
 } from "./enrich";
+export { AiFileVersionConflict, AiFileWriteError, aiFileContentVersion } from "./file-content-version";
+export { AiFileLocation, AiFileReference } from "./file-reference-contracts";
 export {
   AI_FILES_MAX_CONVERSATION_BYTES_DEFAULT,
   AI_FILES_MAX_FILE_BYTES_DEFAULT,
   type AiFileStat,
+  createAiConversationArtifact,
   guessAiMediaType,
   listAiConversationFiles,
   normalizeAiFilePath,
+  readAiConversationFile,
+  writeAiConversationFile,
 } from "./files-store";
 export {
   AI_FIRECRAWL_API_KEY_SETTING_KEY,
@@ -202,6 +215,7 @@ export {
   isNewerWireEvent,
 } from "./protocol";
 export { createAiProvider } from "./provider";
+export { AiQuotaError } from "./quotas";
 export { isConversationResourceCursor } from "./resource-refs";
 export type { AiRoutes } from "./routes";
 export {
@@ -214,7 +228,7 @@ export {
   selectAiModelProfile,
   toPublicAiSettingsState,
 } from "./settings";
-export { AI_SHORT_ID_PATTERN, createAiShortId } from "./short-id";
+export { AI_SHORT_ID_PATTERN, createAiShortId, withAiShortIdForDb } from "./short-id";
 export {
   AI_SKILL_DESCRIPTION_MAX_CHARS,
   AI_SKILL_EXTRA_FRONTMATTER_MAX_CHARS,
@@ -237,7 +251,6 @@ export {
   validateAiSkillName,
   validateAiSkillReferences,
 } from "./skill-format";
-export { seedCloudAiSkills } from "./skill-seeds";
 export {
   type AiLoadedSkillSnapshot,
   type AiSkill,
@@ -251,6 +264,7 @@ export {
   AiSkillRevisionConflictError,
   type AiSkillSummary,
   aiSkills,
+  seedCloudAiSkills,
 } from "./skills";
 export { type AiSkillsRoutes, aiSkillsRoutes } from "./skills-routes";
 export { aiConversations } from "./store";
@@ -273,8 +287,17 @@ export {
   runAiStructured,
 } from "./structured";
 export { aiGlobalInstructionsContext, composeAiSystemPrompt, renderAiGlobalInstructions } from "./system-prompt";
+export { type AiTaskRequest, type AiTaskRequestInput, AiTaskRequestSchema } from "./task-contracts";
+export { executeAiTask } from "./task-execution";
 export { type AiToolApprovalState, type AiToolCallLocation, aiToolAudit } from "./tool-audit";
 export { defineAiTool, isFrontendToolMode, type PreparedAiTools, prepareAiTools } from "./tools";
+export {
+  type AiResolvedAudioModel,
+  createAiTranscriptionProvider,
+  type RunAiTranscriptionInput,
+  resolveAiAudioModel,
+  runAiTranscription,
+} from "./transcription";
 export type {
   AiAccessResult,
   AiCapabilityToolPresentation,

package/src/ai/inference-calls.ts

@@ -0,0 +1,197 @@
+import { type SQL, sql } from "bun";
+import type { AccessSubject } from "../server/services/access";
+import { aiBudgetUnits, aiCostDecimal, aiCostUnits, aiDecimalUnits, hasBillableAiPricing } from "../shared/ai-costs";
+import { AiQuotaError, aiQuotas, quotaWindow } from "./quotas";
+import type { AiModelProfile } from "./types";
+
+export class AiBackgroundCostError extends Error {
+  readonly code = "ai_background_cost_stop";
+  constructor() {
+    super("Background AI is paused by the cost safety limit. An administrator must review Usage rules.");
+  }
+}
+
+/** Admission can fail without latching the instance-wide emergency stop. */
+export class AiBackgroundAdmissionError extends Error {
+  readonly code: string;
+  constructor(readonly retryable: boolean) {
+    super(
+      retryable
+        ? "Background AI budget is reserved by running calls. Try again after they finish."
+        : "This call cannot fit in the remaining background AI budget.",
+    );
+    this.code = retryable ? "ai_background_budget_reserved" : "ai_background_budget_insufficient";
+  }
+}
+
+export type AiCallContext = {
+  kind: "chat" | "background";
+  task: string;
+  subject?: AccessSubject | null;
+  userId?: string;
+  conversationId?: string;
+  turnId?: string;
+  workflowRunId?: string;
+  stepKey?: string;
+  traceId?: string;
+  appId?: string;
+};
+
+export async function backgroundCostState(db: SQL = sql) {
+  const [row] = await db<
+    { used: number; reserved: number; usedExact: string; reservedExact: string; unknown: number; stoppedAt: Date | null; unit: string }[]
+  >`
+    SELECT COALESCE(sum(cost),0)::text AS "usedExact",
+      COALESCE(sum(reserved) FILTER(WHERE finished_at IS NULL AND lease_expires_at>now()),0)::text AS "reservedExact",
+      COALESCE(sum(cost),0)::float8 AS used,
+      COALESCE(sum(reserved) FILTER(WHERE finished_at IS NULL AND lease_expires_at>now()),0)::float8 AS reserved,
+      count(*) FILTER(WHERE (COALESCE((pricing->>'inputPerMillion')::numeric,0)>0 OR COALESCE((pricing->>'outputPerMillion')::numeric,0)>0) AND cost IS NULL AND (finished_at IS NOT NULL OR lease_expires_at<=now()))::int AS unknown,
+      (SELECT background_stopped_at FROM ai.cost_config WHERE singleton) AS "stoppedAt",
+      (SELECT unit FROM ai.cost_config WHERE singleton) AS unit
+    FROM ai.inference_calls WHERE kind='background' AND started_at>=now()-interval '24 hours'`;
+  return row!;
+}
+
+/** Called under the configuration lock; persist transitions before notification delivery. */
+async function checkBackgroundBudget(db: SQL) {
+  const config = await aiQuotas.config(db);
+  const state = await backgroundCostState(db);
+  if (!config.background?.enabled) return state;
+  const [flags] = await db<{ background_warned: boolean }[]>`SELECT background_warned FROM ai.cost_config WHERE singleton`;
+  const warning = config.background.warnAt !== null && aiDecimalUnits(state.usedExact) >= aiBudgetUnits(config.background.warnAt);
+  const stop = aiDecimalUnits(state.usedExact) >= aiBudgetUnits(config.background.stopAt) || state.unknown > 0;
+  for (const kind of [...(warning && !flags!.background_warned ? ["warning"] : []), ...(stop && !state.stoppedAt ? ["stop"] : [])])
+    await db`INSERT INTO ai.cost_alerts(id,kind,cost,unit) VALUES(${crypto.randomUUID()}::uuid,${kind},${state.usedExact}::numeric,${config.unit ?? "EUR"})`;
+  await db`UPDATE ai.cost_config SET background_warned=${warning},
+    background_stopped_at=CASE WHEN ${stop} THEN COALESCE(background_stopped_at,clock_timestamp()) ELSE background_stopped_at END WHERE singleton`;
+  return backgroundCostState(db);
+}
+
+/** Admission and reservation share the settings lock across all worker processes. */
+export async function beginAiCall(
+  profile: AiModelProfile,
+  context: AiCallContext,
+  inputTokens: number,
+  requestedOutput?: number,
+  outputBound?: number,
+) {
+  const result = await sql.begin(async (db) => {
+    await db`SELECT singleton FROM ai.cost_config WHERE singleton FOR UPDATE`;
+    const config = await aiQuotas.config(db);
+    let remaining: bigint | undefined;
+    let backgroundHeadroom: bigint | undefined;
+    if (hasBillableAiPricing(profile.pricing) && context.kind === "background" && config.background?.enabled) {
+      const state = await checkBackgroundBudget(db);
+      if (state.stoppedAt || aiDecimalUnits(state.usedExact) >= aiBudgetUnits(config.background.stopAt) || state.unknown) {
+        await db`UPDATE ai.cost_config SET background_stopped_at=COALESCE(background_stopped_at,clock_timestamp()) WHERE singleton`;
+        return { error: new AiBackgroundCostError() };
+      }
+      backgroundHeadroom = aiBudgetUnits(config.background.stopAt) - aiDecimalUnits(state.usedExact);
+      remaining = backgroundHeadroom - aiDecimalUnits(state.reservedExact);
+    }
+    if (hasBillableAiPricing(profile.pricing) && context.kind === "chat" && context.subject && config.enabled) {
+      const now = new Date();
+      const snapshot = await aiQuotas.snapshot(context.subject, profile.id, now, db);
+      for (const balance of snapshot.balances) {
+        if (balance.bypassed || balance.limit === null) continue;
+        if (balance.unknown)
+          return {
+            error: new AiQuotaError(
+              "quota_usage_unknown",
+              "Chat costs could not be measured. Reset the allowance or wait for the next window.",
+            ),
+          };
+        const rule = config.rules.find((rule) => rule.scope === balance.scope)!;
+        const window = quotaWindow(rule.anchor, rule.hours, now);
+        const user = context.subject.type === "user" ? context.subject.userId : null;
+        const service = context.subject.type === "service_account" ? context.subject.serviceAccountId : null;
+        const [pending] = await db<{ committed: string }[]>`
+          SELECT (COALESCE(sum(cost),0)+COALESCE(sum(reserved) FILTER(WHERE finished_at IS NULL AND lease_expires_at>now()),0))::text AS committed FROM ai.inference_calls c
+          WHERE kind='chat'
+            AND user_id IS NOT DISTINCT FROM ${user}::uuid AND service_account_id IS NOT DISTINCT FROM ${service}::uuid
+            AND (${balance.scope}='*' OR model_profile_id=${balance.scope}) AND started_at>=${window.from} AND started_at<${window.until}
+            AND started_at>COALESCE((SELECT max(created_at) FROM ai.cost_resets r
+              WHERE r.user_id IS NOT DISTINCT FROM ${user}::uuid AND r.service_account_id IS NOT DISTINCT FROM ${service}::uuid AND r.scope=${balance.scope}),'-infinity'::timestamptz)`;
+        const available = aiBudgetUnits(balance.limit) - aiDecimalUnits(pending?.committed ?? "0");
+        remaining = remaining === undefined || available < remaining ? available : remaining;
+      }
+    }
+    let maxOutputTokens = requestedOutput;
+    let reserved = "0";
+    if (profile.pricing && remaining !== undefined) {
+      const inputCost = aiCostUnits(profile.pricing, inputTokens, 0);
+      const outputPrice = aiCostUnits(profile.pricing, 0, 1);
+      const affordable = outputPrice > 0n ? Number((remaining - inputCost) / outputPrice) : Infinity;
+      if (inputCost > remaining || affordable < 1)
+        return {
+          error:
+            context.kind === "background"
+              ? new AiBackgroundAdmissionError(backgroundHeadroom !== undefined && inputCost + outputPrice <= backgroundHeadroom)
+              : new AiQuotaError("quota_exhausted", "Chat cost limit reached."),
+        };
+      const reserveOutput = Math.min(requestedOutput ?? outputBound ?? affordable, affordable);
+      // Preserve adapter defaults unless an explicit maximum or budget requires a cap.
+      if (requestedOutput !== undefined || reserveOutput < (outputBound ?? Infinity)) maxOutputTokens = reserveOutput;
+      reserved = aiCostDecimal(aiCostUnits(profile.pricing, inputTokens, Number.isFinite(reserveOutput) ? reserveOutput : 0));
+    }
+    const workflow = context.workflowRunId
+      ? (
+          await db<{ id: string; name: string; app: string; revision: number }[]>`
+      SELECT w.id,w.name,r.app_id AS app,v.revision FROM workflows.run r
+      JOIN workflows.workflow w ON w.id=r.workflow_id JOIN workflows.version v ON v.id=r.workflow_version_id
+      WHERE r.id=${context.workflowRunId}::uuid`
+        )[0]
+      : undefined;
+    const id = crypto.randomUUID();
+    const userId = context.subject?.type === "user" ? context.subject.userId : context.userId;
+    const serviceId = context.subject?.type === "service_account" ? context.subject.serviceAccountId : null;
+    await db`INSERT INTO ai.inference_calls(id,user_id,service_account_id,model_profile_id,provider_model,kind,task,
+      turn_id,turn_attempt,conversation_id,workflow_run_id,step_key,trace_id,app_id,workflow_id,workflow_name,workflow_version,pricing,reserved,lease_expires_at)
+      VALUES(${id}::uuid,CASE WHEN ${serviceId}::uuid IS NULL THEN COALESCE(${userId ?? null}::uuid,(SELECT created_by_user_id FROM ai.conversations WHERE id=${context.conversationId ?? null}::uuid)) ELSE NULL END,
+        ${serviceId}::uuid,${profile.id},${profile.model},${context.kind},${context.task},${context.turnId ?? null}::uuid,
+        (SELECT attempt FROM ai.turns WHERE id=${context.turnId ?? null}::uuid),${context.conversationId ?? null}::uuid,
+        ${context.workflowRunId ?? null}::uuid,${context.stepKey ?? null},${context.traceId ?? null},COALESCE(${workflow?.app ?? context.appId ?? null},(SELECT launched_by_app_id FROM ai.conversations WHERE id=${context.conversationId ?? null}::uuid),'core'),${workflow?.id ?? null}::uuid,${workflow?.name ?? null},${workflow?.revision ?? null},
+        (${profile.pricing ? JSON.stringify(profile.pricing) : null}::text)::jsonb,${reserved}::numeric,now()+interval '2 minutes')`;
+    return { id, maxOutputTokens };
+  });
+  if (result.error) throw result.error;
+  return { id: result.id!, maxOutputTokens: result.maxOutputTokens };
+}
+
+export async function finishAiCall(
+  id: string,
+  usage: { input: number; output: number; estimated?: boolean } | undefined,
+  status: "ok" | "failed",
+) {
+  await sql.begin(async (db) => {
+    await db`SELECT singleton FROM ai.cost_config WHERE singleton FOR UPDATE`;
+    const [call] = await db<
+      { pricing: AiModelProfile["pricing"]; kind: string }[]
+    >`SELECT pricing,kind FROM ai.inference_calls WHERE id=${id}::uuid AND finished_at IS NULL FOR UPDATE`;
+    if (!call) return;
+    const cost =
+      call.pricing?.inputPerMillion === 0 && call.pricing.outputPerMillion === 0
+        ? "0"
+        : call.pricing && usage
+          ? aiCostDecimal(aiCostUnits(call.pricing, usage.input, usage.output))
+          : null;
+    await db`UPDATE ai.inference_calls SET input=${usage?.input ?? null},output=${usage?.output ?? null},estimated=${usage?.estimated ?? false},
+      cost=${cost}::numeric,reserved=0,finished_at=clock_timestamp(),status=${status},error_code=${status === "failed" ? "ai_provider_call_failed" : null} WHERE id=${id}::uuid`;
+    if (call.kind === "background") await checkBackgroundBudget(db);
+  });
+}
+
+export async function releaseBackgroundCostStop(actorId: string) {
+  return sql.begin(async (db) => {
+    await db`SELECT singleton FROM ai.cost_config WHERE singleton FOR UPDATE`;
+    const config = await aiQuotas.config(db);
+    const state = await backgroundCostState(db);
+    if (config.background?.enabled && (aiDecimalUnits(state.usedExact) >= aiBudgetUnits(config.background.stopAt) || state.unknown))
+      throw new AiBackgroundCostError();
+    if (!state.stoppedAt) return state;
+    await db`UPDATE ai.cost_config SET background_stopped_at=NULL,background_warned=false,revision=revision+1 WHERE singleton`;
+    const next = await aiQuotas.config(db);
+    await db`INSERT INTO ai.cost_changes(revision,actor_id,config) VALUES(${next.revision},${actorId}::uuid,(${JSON.stringify({ ...next, action: "release-background-stop" })}::text)::jsonb)`;
+    return backgroundCostState(db);
+  });
+}

package/src/ai/live-events.ts

@@ -7,6 +7,7 @@ export const AI_INVALIDATION_DOMAINS = [
   "conversation-sources",
   "conversation-files",
   "conversation-tasks",
+  "conversation-dictations",
   "project-list",
   "project-detail",
   "project-context",
@@ -129,7 +130,10 @@ const AiConversationSchema = z
     keywords: z.array(z.string()),
     pinnedAt: z.string().nullable(),
     archivedAt: z.string().nullable(),
-    runStatus: z.enum(["idle", "queued", "running", "needs_attention", "failed"]),
+    done: z.boolean().nullable(),
+    isDone: z.boolean(),
+    lastUsedAt: z.string(),
+    runStatus: z.enum(["idle", "queued", "running", "needs_attention", "waiting_for_browser", "failed"]),
     runError: z.string().nullable(),
     unreadCompletion: z.boolean(),
     projectId: z.string().nullable(),

package/src/ai/live.ts

@@ -1,2 +1,2 @@
 export { latestAiInvalidationCursor } from "./live-outbox";
-export { aiLiveRoutes, type AiLiveRoutes, type AiLiveRoutesConfig } from "./live-routes";
+export { type AiLiveRoutes, type AiLiveRoutesConfig, aiLiveRoutes } from "./live-routes";

package/src/ai/markdown-pdf-tool.ts

@@ -1,3 +1,4 @@
+import { z } from "zod";
 import {
   MARKDOWN_PDF_MAX_CUSTOM_CSS_BYTES,
   MARKDOWN_PDF_MAX_MARKDOWN_BYTES,
@@ -5,9 +6,8 @@ import {
   type RenderMarkdownToPdfInput,
   renderMarkdownToPdf,
 } from "../services/pdf";
-import { z } from "zod";
 import { aiProjectFilePathFromMount } from "./file-mount";
-import { aiFileStore, normalizeAiFilePath, type AiFileContent } from "./files-store";
+import { type AiFileContent, aiFileStore, normalizeAiFilePath } from "./files-store";
 import { defineAiTool } from "./tools";
 
 export const CloudAiMarkdownToPdfInputSchema = z

package/src/ai/memories.ts

@@ -459,9 +459,7 @@ export const aiMemories = {
           action: "retired" as const,
           kind: memory.kind,
           content: memory.content,
-          ...(memory.resource_type && memory.resource_id
-            ? { resourceRef: { type: memory.resource_type, id: memory.resource_id } }
-            : {}),
+          ...(memory.resource_type && memory.resource_id ? { resourceRef: { type: memory.resource_type, id: memory.resource_id } } : {}),
         }));
       }
 
@@ -509,19 +507,20 @@ export const aiMemories = {
         );
         const created = rows[0];
         return created
-          ? [{
-              action: "added",
-              kind: created.kind,
-              content: created.content,
-              ...(resourceRef ? { resourceRef } : {}),
-            }]
+          ? [
+              {
+                action: "added",
+                kind: created.kind,
+                content: created.content,
+                ...(resourceRef ? { resourceRef } : {}),
+              },
+            ]
           : [];
       }
 
       if (duplicate && !targets.some((memory) => memory.id === duplicate.id)) {
         const duplicateResourceMatches =
-          proposal.kind !== "workflow" ||
-          (duplicate.resource_type === resourceRef?.type && duplicate.resource_id === resourceRef?.id);
+          proposal.kind !== "workflow" || (duplicate.resource_type === resourceRef?.type && duplicate.resource_id === resourceRef?.id);
         if (duplicate.kind !== proposal.kind || !duplicateResourceMatches) return [];
         await tx`
           UPDATE ai.memories old
@@ -532,15 +531,17 @@ export const aiMemories = {
             AND old.source = 'background' AND old.priority = 'normal'
             AND old.deleted_at IS NULL AND old.superseded_by_id IS NULL
         `;
-        return [{
-          action: "merged",
-          kind: duplicate.kind,
-          content: duplicate.content,
-          previousContent: targets.map((memory) => memory.content).join(" · "),
-          ...(duplicate.resource_type && duplicate.resource_id
-            ? { resourceRef: { type: duplicate.resource_type, id: duplicate.resource_id } }
-            : {}),
-        }];
+        return [
+          {
+            action: "merged",
+            kind: duplicate.kind,
+            content: duplicate.content,
+            previousContent: targets.map((memory) => memory.content).join(" · "),
+            ...(duplicate.resource_type && duplicate.resource_id
+              ? { resourceRef: { type: duplicate.resource_type, id: duplicate.resource_id } }
+              : {}),
+          },
+        ];
       }
 
       const destination = targets[0]!;
@@ -565,13 +566,15 @@ export const aiMemories = {
             AND deleted_at IS NULL AND superseded_by_id IS NULL
         `;
       }
-      return [{
-        action: proposal.action === "merge" ? "merged" : "updated",
-        kind: proposal.kind,
-        content,
-        previousContent: targets.map((memory) => memory.content).join(" · "),
-        ...(resourceRef ? { resourceRef } : {}),
-      }];
+      return [
+        {
+          action: proposal.action === "merge" ? "merged" : "updated",
+          kind: proposal.kind,
+          content,
+          previousContent: targets.map((memory) => memory.content).join(" · "),
+          ...(resourceRef ? { resourceRef } : {}),
+        },
+      ];
     });
   },
 

package/src/ai/memory-learning-runs.ts

@@ -1,7 +1,7 @@
 import { sql } from "bun";
 import type { CloudResourceRef } from "../contracts/capabilities";
-import { withAiShortId } from "./short-id";
 import type { AiMemoryKind } from "./memories";
+import { withAiShortId } from "./short-id";
 
 export type AiMemoryLearningRunStatus = "running" | "ok" | "skipped" | "failed";
 export type AiMemoryLearningRunKind = "turn" | "workflow";