@k2b/cloud 0.41.0 → 0.42.0

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,8 +2,8 @@ import { type Context, Hono } from "hono";
 import { bodyLimit } from "hono/body-limit";
 import { describeRoute } from "hono-openapi";
 import { z } from "zod";
+import { CAPABILITY_DISCOVERY_TIMEOUT_MS, capabilityTimeoutMs } from "../_internal/capability-timeout";
 import { getApp, listCapabilities } from "../_internal/registry";
-import { QUERY_TIMEOUT_MS } from "../api/capabilities";
 import { ErrorResponseSchema } from "../contracts";
 import { APPROVAL_CLIENT_HEADER } from "../contracts/approvals";
 import { capabilityActionPolicy } from "../contracts/capabilities";
@@ -27,6 +27,8 @@ 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 { 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";
@@ -99,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";
@@ -286,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" });
@@ -433,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,
@@ -447,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");
@@ -497,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,
@@ -577,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,
@@ -585,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.")));
           }
@@ -616,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);
@@ -642,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;
@@ -1223,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,
@@ -1256,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) =>
@@ -1371,7 +1409,7 @@ export const aiRoutes = (() => {
             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) : null;
+            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;

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;
 

package/src/ai/skill-tool.ts

@@ -1,5 +1,6 @@
 import { z } from "zod";
 import type { AccessSubject } from "../server";
+import type { RequestAuthority } from "../server/middleware/auth";
 import { AI_SKILL_FILE_MOUNT } from "./file-mount";
 import { AI_SHORT_ID_PATTERN } from "./short-id";
 import { type AiSkillCatalogEntry, mergeAiSkillCatalog, rankAiSkillCatalog, searchAiSkillCatalog } from "./skill-catalog";
@@ -8,11 +9,17 @@ import { aiSkills } from "./skills";
 import { defineAiTool } from "./tools";
 
 /** Explicit selections use the same permission check and turn snapshot as load_skill. */
-export async function loadSelectedAiSkills(ids: readonly string[], turnId: string, subject: AccessSubject | null, allowed: boolean) {
+export async function loadSelectedAiSkills(
+  ids: readonly string[],
+  turnId: string,
+  subject: AccessSubject | null,
+  allowed: boolean,
+  authority: RequestAuthority | null = null,
+) {
   const loaded = [];
   for (const id of new Set(ids)) {
     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);
+    const skill = await aiSkills.loadForTurn(turnId, { id }, subject, authority);
     if (!skill) throw new Error(`Selected Skill ${id} is unavailable or access was revoked.`);
     loaded.push({
       name: skill.name,
@@ -51,7 +58,7 @@ export const CloudAiLoadSkillOutputSchema = z.object({
   files: z.array(z.string()),
 });
 
-export const createCloudAiLoadSkillTool = (subject: AccessSubject) =>
+export const createCloudAiLoadSkillTool = (subject: AccessSubject, authority: RequestAuthority | null = null) =>
   defineAiTool({
     name: "load_skill",
     description:
@@ -62,7 +69,7 @@ export const createCloudAiLoadSkillTool = (subject: AccessSubject) =>
   }).server(async (input, ctx) => {
     if (!ctx.turnId) throw new Error("load_skill requires a turn context.");
     const selector = input.id ? { id: input.id } : input.name;
-    const snapshot = selector ? await aiSkills.loadForTurn(ctx.turnId, selector, subject) : null;
+    const snapshot = selector ? await aiSkills.loadForTurn(ctx.turnId, selector, subject, authority) : null;
     if (!snapshot) throw new Error(`Skill "${input.id ?? input.name}" is unavailable or access was revoked.`);
     return {
       name: snapshot.name,
@@ -84,7 +91,11 @@ export const CloudAiSearchSkillsOutputSchema = z.object({
   more: z.boolean(),
 });
 
-export const createCloudAiSearchSkillsTool = (subject: AccessSubject | null, localSkills: readonly AiSkillCatalogEntry[] = []) =>
+export const createCloudAiSearchSkillsTool = (
+  subject: AccessSubject | null,
+  localSkills: readonly AiSkillCatalogEntry[] = [],
+  authority: RequestAuthority | null = null,
+) =>
   defineAiTool({
     name: "search_skills",
     description:
@@ -94,7 +105,7 @@ export const createCloudAiSearchSkillsTool = (subject: AccessSubject | null, loc
     approval: "never",
   }).server(async (input) => {
     const result = subject
-      ? await aiSkills.search(subject, input.query, input.limit + localSkills.length, { modelInvocableOnly: true })
+      ? await aiSkills.search(subject, input.query, input.limit + localSkills.length, { modelInvocableOnly: true, authority })
       : { skills: [], more: false };
     const cloud = result.skills.map(({ name, description }) => ({ name, description }));
     if (!localSkills.length) return { skills: cloud, more: result.more };

package/src/ai/skills-routes.ts

@@ -1,9 +1,13 @@
 import { Hono, type MiddlewareHandler } from "hono";
 import { HTTPException } from "hono/http-exception";
 import { z } from "zod";
+import { getApp } from "../_internal/registry";
 import { AuthenticatedPrincipalSchema } from "../contracts/shared";
 import { type AuthContext, auth, err, fail, ok, rateLimit, respond, v } from "../server";
+import { appAccessDeniedBody } from "../server/middleware/app-access";
 import { noTransform } from "../server/middleware/no-transform";
+import { appAccessAuthority, canUseApp } from "../services/app-access";
+import { recordAppAccessDenied } from "../services/app-access-metrics";
 import { localizedAppName } from "../ssr/runtime";
 import { aiProjects } from "./projects";
 import {
@@ -62,6 +66,20 @@ type AiSkillsRouteDependencies = {
   authenticate?: MiddlewareHandler<AuthContext>;
 };
 
+// Core exempts this mixed router from its method-independent public-path gate.
+// Only list/get are brokers; management retains Core entry and its user-backed policy.
+const requireCoreAccess: MiddlewareHandler<AuthContext> = async (c, next) => {
+  const core = await getApp("core").catch(() => null);
+  const allowed = core && (await canUseApp(appAccessAuthority(c), core).catch(() => false));
+  if (!allowed) {
+    if (core) recordAppAccessDenied(core.id);
+    c.header("Cache-Control", "private, no-store");
+    c.header("X-Cloud-App-Access-Denied", "core");
+    return c.json(appAccessDeniedBody(core ?? { id: "core", name: "Core" }), 403);
+  }
+  await next();
+};
+
 const buildAiSkillsRoutes = (dependencies: AiSkillsRouteDependencies = {}) =>
   new Hono<AuthContext>()
     // The list combines skills from separate grants; the writer of one can rename it next to another skill's text.
@@ -86,13 +104,19 @@ const buildAiSkillsRoutes = (dependencies: AiSkillsRouteDependencies = {}) =>
         const { q, name } = c.req.valid("query");
         const skills =
           name !== undefined
-            ? await aiSkills.list(subject, { name })
+            ? await aiSkills.list(subject, { name, authority: appAccessAuthority(c) })
             : q === undefined
-              ? await aiSkills.list(subject)
-              : (await aiSkills.search(subject, q)).skills;
+              ? await aiSkills.list(subject, { authority: appAccessAuthority(c) })
+              : (await aiSkills.search(subject, q, 30, { authority: appAccessAuthority(c) })).skills;
         return respond(c, ok({ skills: skills.map(publicSummary(c)) }));
       },
     )
+    .get("/:skillId", async (c) => {
+      const skill = await aiSkills.getByShortId(c.req.param("skillId")!, c.get("accessSubject") ?? null, "read", appAccessAuthority(c));
+      return skill ? respond(c, ok({ skill: publicSkill(c, skill) })) : respond(c, fail(err.notFound("Skill")));
+    })
+    .use("*", requireCoreAccess)
+    .use("*", auth.requireUser())
     .get(
       "/project-links/:projectId",
       v(
@@ -108,7 +132,12 @@ const buildAiSkillsRoutes = (dependencies: AiSkillsRouteDependencies = {}) =>
           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" })
+          ? await aiSkills.projectSkills(project.id, subject, {
+              query: query.q,
+              page: query.page,
+              available: query.available === "true",
+              authority: appAccessAuthority(c),
+            })
           : null;
         return result
           ? respond(c, ok({ ...result, items: result.items.map(publicSummary(c)) }))
@@ -117,8 +146,8 @@ const buildAiSkillsRoutes = (dependencies: AiSkillsRouteDependencies = {}) =>
     )
     .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;
+      const skill = await aiSkills.getByShortId(c.req.param("skillId")!, subject, "admin", appAccessAuthority(c));
+      const projects = skill ? await aiSkills.linkedProjects(skill.id, subject, appAccessAuthority(c)) : null;
       return projects
         ? respond(c, ok({ projects: projects.map((project) => ({ id: project.shortId, name: project.name })) }))
         : respond(c, fail(err.notFound("Skill")));
@@ -126,11 +155,11 @@ const buildAiSkillsRoutes = (dependencies: AiSkillsRouteDependencies = {}) =>
     .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"),
+        aiSkills.getByShortId(c.req.param("skillId")!, subject, "admin", appAccessAuthority(c)),
         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))
+      return skill && project && (await aiSkills.linkProject(skill.id, project.id, linked, subject, appAccessAuthority(c)))
         ? respond(c, ok({ linked }))
         : respond(c, fail(err.notFound("Skill or Project")));
     })
@@ -138,22 +167,22 @@ const buildAiSkillsRoutes = (dependencies: AiSkillsRouteDependencies = {}) =>
       const subject = c.get("accessSubject");
       if (!subject) return respond(c, fail(err.forbidden("Skills require an authenticated access subject.")));
       try {
-        return respond(c, ok({ skill: publicSkill(c, await aiSkills.create({ subject, ...c.req.valid("json") })) }), 201);
+        return respond(
+          c,
+          ok({ skill: publicSkill(c, await aiSkills.create({ subject, ...c.req.valid("json") }, appAccessAuthority(c))) }),
+          201,
+        );
       } catch (error) {
         if (isUniqueViolation(error)) return respond(c, fail(err.conflict("A skill with this name already exists.")));
         if (error instanceof AiSkillInputError) return respond(c, fail(err.badInput(error.message)));
         throw error;
       }
     })
-    .get("/:skillId", async (c) => {
-      const skill = await aiSkills.getByShortId(c.req.param("skillId")!, c.get("accessSubject") ?? null);
-      return skill ? respond(c, ok({ skill: publicSkill(c, skill) })) : respond(c, fail(err.notFound("Skill")));
-    })
     .put("/:skillId", v("json", UpdateSkillSchema), async (c) => {
-      const existing = await aiSkills.getByShortId(c.req.param("skillId")!, c.get("accessSubject") ?? null, "write");
+      const existing = await aiSkills.getByShortId(c.req.param("skillId")!, c.get("accessSubject") ?? null, "write", appAccessAuthority(c));
       if (!existing) return respond(c, fail(err.notFound("Skill")));
       try {
-        const skill = await aiSkills.update(existing.id, c.get("accessSubject") ?? null, c.req.valid("json"));
+        const skill = await aiSkills.update(existing.id, c.get("accessSubject") ?? null, c.req.valid("json"), appAccessAuthority(c));
         return skill ? respond(c, ok({ skill: publicSkill(c, skill) })) : respond(c, fail(err.notFound("Skill")));
       } catch (error) {
         if (isUniqueViolation(error)) return respond(c, fail(err.conflict("A skill with this name already exists.")));
@@ -163,32 +192,41 @@ const buildAiSkillsRoutes = (dependencies: AiSkillsRouteDependencies = {}) =>
       }
     })
     .delete("/:skillId", async (c) => {
-      const skill = await aiSkills.getByShortId(c.req.param("skillId")!, c.get("accessSubject") ?? null, "admin");
-      return skill && (await aiSkills.delete(skill.id, c.get("accessSubject") ?? null))
+      const skill = await aiSkills.getByShortId(c.req.param("skillId")!, c.get("accessSubject") ?? null, "admin", appAccessAuthority(c));
+      return skill && (await aiSkills.delete(skill.id, c.get("accessSubject") ?? null, appAccessAuthority(c)))
         ? respond(c, ok({ deleted: true }))
         : respond(c, fail(err.notFound("Skill")));
     })
     .put("/:skillId/enabled", dependencies.authenticate ?? auth.requireRole("authenticated"), v("json", SkillEnabledSchema), async (c) => {
       const subject = c.get("accessSubject") ?? null;
-      const skill = await aiSkills.getByShortId(c.req.param("skillId")!, subject);
-      const enabled = skill ? await aiSkills.setEnabled(skill.id, subject, c.req.valid("json").enabled) : null;
+      const skill = await aiSkills.getByShortId(c.req.param("skillId")!, subject, "read", appAccessAuthority(c));
+      const enabled = skill ? await aiSkills.setEnabled(skill.id, subject, c.req.valid("json").enabled, appAccessAuthority(c)) : null;
       return enabled === null ? respond(c, fail(err.notFound("Skill"))) : respond(c, ok({ enabled }));
     })
     .get("/:skillId/access", async (c) => {
-      const skill = await aiSkills.getByShortId(c.req.param("skillId")!, c.get("accessSubject") ?? null, "admin");
-      const access = skill ? await aiSkills.listAccess(skill.id, c.get("accessSubject") ?? null) : null;
+      const skill = await aiSkills.getByShortId(c.req.param("skillId")!, c.get("accessSubject") ?? null, "admin", appAccessAuthority(c));
+      const access = skill ? await aiSkills.listAccess(skill.id, c.get("accessSubject") ?? null, appAccessAuthority(c)) : null;
       return access ? respond(c, ok({ access })) : respond(c, fail(err.notFound("Skill")));
     })
     .post("/:skillId/access", v("json", SkillAccessSchema), async (c) => {
-      const skill = await aiSkills.getByShortId(c.req.param("skillId")!, c.get("accessSubject") ?? null, "admin");
-      const access = skill ? await aiSkills.grantAccess(skill.id, c.get("accessSubject") ?? null, c.req.valid("json")) : null;
+      const skill = await aiSkills.getByShortId(c.req.param("skillId")!, c.get("accessSubject") ?? null, "admin", appAccessAuthority(c));
+      const access = skill
+        ? await aiSkills.grantAccess(skill.id, c.get("accessSubject") ?? null, c.req.valid("json"), undefined, appAccessAuthority(c))
+        : null;
       return access ? respond(c, ok({ access }), 201) : respond(c, fail(err.notFound("Skill")));
     })
     .patch("/:skillId/access/:accessId", v("json", SkillAccessUpdateSchema), async (c) => {
-      const skill = await aiSkills.getByShortId(c.req.param("skillId")!, c.get("accessSubject") ?? null, "admin");
+      const skill = await aiSkills.getByShortId(c.req.param("skillId")!, c.get("accessSubject") ?? null, "admin", appAccessAuthority(c));
       try {
         return skill &&
-          (await aiSkills.updateAccess(skill.id, c.req.param("accessId")!, c.get("accessSubject") ?? null, c.req.valid("json").permission))
+          (await aiSkills.updateAccess(
+            skill.id,
+            c.req.param("accessId")!,
+            c.get("accessSubject") ?? null,
+            c.req.valid("json").permission,
+            undefined,
+            appAccessAuthority(c),
+          ))
           ? respond(c, ok({ updated: true }))
           : respond(c, fail(err.notFound("Access entry")));
       } catch (error) {
@@ -197,9 +235,16 @@ const buildAiSkillsRoutes = (dependencies: AiSkillsRouteDependencies = {}) =>
       }
     })
     .delete("/:skillId/access/:accessId", async (c) => {
-      const skill = await aiSkills.getByShortId(c.req.param("skillId")!, c.get("accessSubject") ?? null, "admin");
+      const skill = await aiSkills.getByShortId(c.req.param("skillId")!, c.get("accessSubject") ?? null, "admin", appAccessAuthority(c));
       try {
-        return skill && (await aiSkills.revokeAccess(skill.id, c.req.param("accessId")!, c.get("accessSubject") ?? null))
+        return skill &&
+          (await aiSkills.revokeAccess(
+            skill.id,
+            c.req.param("accessId")!,
+            c.get("accessSubject") ?? null,
+            undefined,
+            appAccessAuthority(c),
+          ))
           ? respond(c, ok({ deleted: true }))
           : respond(c, fail(err.notFound("Access entry")));
       } catch (error) {